@aztec-labs/pxe 6.0.0-nightly.20260829

package/src/entrypoints/server/circuit_recording/circuit_recorder.ts

@@ -0,0 +1,267 @@
+import type { ForeignCallHandler, ForeignCallInput, ForeignCallOutput } from '@aztec/noir-acvm_js';
+
+import { sha512 } from '@aztec-labs/foundation/crypto/sha512';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import type { ACIRCallback, ACVMWitness } from '@aztec-labs/simulator/client';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export type OracleCall = {
+  name: string;
+  inputs: unknown[];
+  outputs: unknown;
+  time: number;
+  // Due to the recursive nature of the simulator, we might have
+  // oracle calls performed after a foreign call (which is itself an oracle call)
+  // We keep track of the stack depth in this variable to ensure the recorded oracle
+  // calls are correctly associated with the right circuit.
+  // This is only use as a debugging tool
+  stackDepth: number;
+};
+
+export class CircuitRecording {
+  circuitName: string;
+  functionName: string;
+  bytecodeSHA512Hash: string;
+  timestamp: number;
+  inputs: Record<string, string>;
+  oracleCalls: OracleCall[];
+  error?: string;
+  parent?: CircuitRecording;
+
+  constructor(circuitName: string, functionName: string, bytecodeSHA512Hash: string, inputs: Record<string, string>) {
+    this.circuitName = circuitName;
+    this.functionName = functionName;
+    this.bytecodeSHA512Hash = bytecodeSHA512Hash;
+    this.timestamp = Date.now();
+    this.inputs = inputs;
+    this.oracleCalls = [];
+  }
+
+  setParent(recording?: CircuitRecording): void {
+    this.parent = recording;
+  }
+}
+
+/** Inputs needed to open a recording for a single circuit execution. */
+export type RecordingMetadata = {
+  input: ACVMWitness;
+  bytecode: Buffer;
+  circuitName: string;
+  functionName: string;
+};
+
+/**
+ * Class responsible for recording circuit inputs necessary to replay the circuit. These inputs are the initial witness
+ * map and the oracle calls made during the circuit execution/witness generation.
+ *
+ * The active recording for an execution lives in `AsyncLocalStorage`, so each (possibly nested) circuit execution owns
+ * its own recording and concurrent or re-entrant executions cannot corrupt one another's state. Nested executions
+ * (`aztec_prv_callPrivateFunction`, utility calls) re-enter {@link record}, which links the child to the recording
+ * active in the enclosing async context and lets ALS restore the parent automatically when the child completes.
+ *
+ * Example recording object:
+ * ```json
+ * {
+ *   "circuitName": "AMM",
+ *   "functionName": "add_liquidity",
+ *   "bytecodeSHA512Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
+ *   "timestamp": 1740691464360,
+ *   "inputs": {
+ *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
+ *     "1": "0x00f4d59c0ff773427bb0fed5b422557ca4dc5655abe53d31fa9408cb3c5a672f",
+ *     "5": "0x000000000000000000000000000000000000000000000000000000000000000f"
+ *   },
+ *   "oracleCalls": [
+ *     {
+ *       "name": "loadCapsule",
+ *       "inputs": [
+ *         [
+ *           "0x102422483bad6abd385948435667e144ac4c272576e325e7563608876cd446fd"
+ *         ],
+ *         [
+ *           "0x000000000000000000000000000000000000000000000000000000000000004d"
+ *         ],
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000001"
+ *         ]
+ *       ],
+ *       "outputs": [
+ *         "0x0000000000000000000000000000000000000000000000000000000000000000",
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000000"
+ *         ]
+ *       ]
+ *     },
+ *     {
+ *       "name": "fetchTaggedLogs",
+ *       "inputs": []
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+export class CircuitRecorder {
+  protected readonly logger: Logger;
+
+  readonly #recordings = new AsyncLocalStorage<CircuitRecording>();
+
+  protected constructor(loggerOrBindings?: Logger | LoggerBindings) {
+    this.logger = resolveLogger('simulator:acvm:recording', loggerOrBindings);
+  }
+
+  /**
+   * Records a single circuit execution. Opens a recording for the circuit (linked as a child of the recording active
+   * in the current async context, if any), runs `fn` within that recording's context, and finalizes it. The recording
+   * is returned alongside the result so callers can derive per-circuit stats (e.g. oracle timings).
+   *
+   * Recorder bookkeeping never alters execution: if `fn` throws, the error is attached to the recording and re-thrown
+   * unchanged.
+   * @param metadata - Identifies the circuit and its initial witness.
+   * @param fn - Runs the circuit execution; its oracle calls are recorded into this recording.
+   */
+  record<T>(metadata: RecordingMetadata, fn: () => Promise<T>): Promise<{ result: T; recording: CircuitRecording }> {
+    const parent = this.#recordings.getStore();
+    const recording = new CircuitRecording(
+      metadata.circuitName,
+      metadata.functionName,
+      sha512(metadata.bytecode).toString('hex'),
+      Object.fromEntries(metadata.input),
+    );
+    recording.setParent(parent);
+
+    return this.#recordings.run(recording, async () => {
+      await this.onStart(recording);
+      try {
+        const result = await fn();
+        await this.onFinish(recording);
+        return { result, recording };
+      } catch (error) {
+        recording.error = JSON.stringify(error);
+        await this.onError(recording, error);
+        throw error;
+      }
+    });
+  }
+
+  /**
+   * Wraps a callback to record all oracle/foreign calls.
+   * @param callback - The original callback to wrap, either a user circuit callback or protocol circuit callback.
+   * @returns A wrapped callback that records all oracle interactions.
+   */
+  wrapCallback(callback: ACIRCallback | ForeignCallHandler | undefined): ACIRCallback | ForeignCallHandler | undefined {
+    if (!callback) {
+      return undefined;
+    }
+    if (this.#isACIRCallback(callback)) {
+      return this.#wrapUserCircuitCallback(callback);
+    }
+    return this.#wrapProtocolCircuitCallback(callback);
+  }
+
+  /**
+   * Type guard to check if a callback is an ACIRCallback.
+   */
+  #isACIRCallback(callback: ACIRCallback | ForeignCallHandler): callback is ACIRCallback {
+    return typeof callback === 'object' && callback !== null && !('call' in callback);
+  }
+
+  /**
+   * Wraps a user circuit callback to record all oracle calls. A nested circuit entered via an oracle (e.g.
+   * `aztec_prv_callPrivateFunction`) re-enters {@link record}, so its own oracle calls land on the child recording and
+   * this circuit's calls (including the entering oracle call itself) land on this recording once the child completes.
+   * @param callback - The original circuit callback.
+   * @returns A wrapped callback that records all oracle interactions which is to be provided to the ACVM.
+   */
+  #wrapUserCircuitCallback(callback: ACIRCallback): ACIRCallback {
+    const recordingCallback: ACIRCallback = {} as ACIRCallback;
+    const oracleMethods = Object.keys(callback);
+
+    for (const name of oracleMethods) {
+      const fn = callback[name as keyof ACIRCallback];
+      if (!fn || typeof fn !== 'function') {
+        throw new Error(`Oracle method ${name} not found when setting up recording callback`);
+      }
+
+      recordingCallback[name as keyof ACIRCallback] = (...args: ForeignCallInput[]): ReturnType<typeof fn> => {
+        const timer = new Timer();
+        const result = fn.call(callback, ...args);
+        if (result instanceof Promise) {
+          return result.then(async r => {
+            await this.recordCall(name, args, r, timer.ms());
+            return r;
+          }) as ReturnType<typeof fn>;
+        }
+        void this.recordCall(name, args, result, timer.ms());
+        return result;
+      };
+    }
+
+    return recordingCallback;
+  }
+
+  /**
+   * Wraps a protocol circuit callback to record all oracle calls.
+   * @param callback - The original oracle circuit callback.
+   * @returns A wrapped handler that records all oracle interactions which is to be provided to the ACVM.
+   */
+  #wrapProtocolCircuitCallback(callback: ForeignCallHandler): ForeignCallHandler {
+    return async (name: string, inputs: ForeignCallInput[]): Promise<ForeignCallOutput[]> => {
+      const timer = new Timer();
+      const result = await callback(name, inputs);
+      await this.recordCall(name, inputs, result, timer.ms());
+      return result;
+    };
+  }
+
+  /**
+   * Records a single oracle/foreign call with its inputs and outputs against the recording active in the current
+   * async context.
+   * @param name - Name of the call
+   * @param inputs - Input arguments
+   * @param outputs - Output results
+   */
+  recordCall(name: string, inputs: unknown[], outputs: unknown, time: number): Promise<OracleCall> {
+    const recording = this.#recordings.getStore();
+    const entry = {
+      name,
+      inputs,
+      outputs,
+      time,
+      stackDepth: depthOf(recording),
+    };
+    // Outside any active recording context (e.g. a stray call after the scope closed, or a direct unit-test call)
+    // there is nowhere to record; return the entry without throwing into the execution path.
+    recording?.oracleCalls.push(entry);
+    return Promise.resolve(entry);
+  }
+
+  /** The recording active in the current async context, if any. */
+  protected currentRecording(): CircuitRecording | undefined {
+    return this.#recordings.getStore();
+  }
+
+  /** Hook invoked when a recording opens, within the recording's context. Overridden to persist recordings. */
+  protected onStart(_recording: CircuitRecording): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Hook invoked when a recording completes successfully, within the recording's context. */
+  protected onFinish(_recording: CircuitRecording): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Hook invoked when a recording's execution throws, within the recording's context. */
+  protected onError(_recording: CircuitRecording, _error: unknown): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+/** Depth of a recording in the call tree: 0 for a top-level circuit, incremented per nested circuit. */
+function depthOf(recording: CircuitRecording | undefined): number {
+  let depth = 0;
+  for (let ancestor = recording?.parent; ancestor; ancestor = ancestor.parent) {
+    depth++;
+  }
+  return depth;
+}

package/src/entrypoints/server/circuit_recording/file_circuit_recorder.ts

@@ -0,0 +1,152 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import fs from 'fs/promises';
+import path from 'path';
+
+import { CircuitRecorder, type CircuitRecording } from './circuit_recorder.js';
+
+/** Per-recording file state, keyed by recording so concurrent/nested executions don't share it. */
+type RecordingFileState = { filePath: string; isFirstCall: boolean };
+
+export class FileCircuitRecorder extends CircuitRecorder {
+  readonly #fileState = new WeakMap<CircuitRecording, RecordingFileState>();
+
+  constructor(
+    private readonly recordDir: string,
+    logger?: Logger,
+  ) {
+    super(logger);
+  }
+
+  protected override async onStart(recording: CircuitRecording): Promise<void> {
+    const recordingStringWithoutClosingBracket = JSON.stringify(
+      { ...recording, parent: undefined, oracleCalls: undefined },
+      null,
+      2,
+    ).slice(0, -2);
+
+    try {
+      // Check if the recording directory exists and is a directory
+      const stats = await fs.stat(this.recordDir);
+      if (!stats.isDirectory()) {
+        throw new Error(`Recording path ${this.recordDir} exists but is not a directory`);
+      }
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        // The directory does not exist so we create it
+        await fs.mkdir(this.recordDir, { recursive: true });
+      } else {
+        throw err;
+      }
+    }
+
+    const filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(
+      this.recordDir,
+      recording.circuitName,
+      recording.functionName,
+      recordingStringWithoutClosingBracket,
+    );
+    this.#fileState.set(recording, { filePath, isFirstCall: true });
+  }
+
+  /**
+   * Computes a unique file path for the recording by trying different counter values.
+   * This is needed because multiple recordings of the same circuit could be happening simultaneously or an older
+   * recording might be present.
+   * @param recordDir - Directory to store the recording
+   * @param circuitName - Name of the circuit
+   * @param functionName - Name of the circuit function
+   * @param recordingContent - Initial recording content
+   * @returns A unique file path for the recording
+   */
+  static async #computeFilePathAndStoreInitialRecording(
+    recordDir: string,
+    circuitName: string,
+    functionName: string,
+    recordingContent: string,
+  ): Promise<string> {
+    let counter = 0;
+    while (true) {
+      try {
+        const filePath = getFilePath(recordDir, circuitName, functionName, counter);
+        // Write the initial recording content to the file
+        await fs.writeFile(filePath, recordingContent + ',\n  "oracleCalls": [\n', {
+          flag: 'wx', // wx flag fails if file exists
+        });
+        return filePath;
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
+          counter++;
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Records a single oracle/foreign call with its inputs and outputs.
+   * @param name - Name of the call
+   * @param inputs - Input arguments
+   * @param outputs - Output results
+   */
+  override async recordCall(name: string, inputs: unknown[], outputs: unknown, time: number) {
+    const entry = await super.recordCall(name, inputs, outputs, time);
+    const recording = this.currentRecording();
+    const state = recording && this.#fileState.get(recording);
+    if (state) {
+      try {
+        const prefix = state.isFirstCall ? '    ' : '    ,';
+        state.isFirstCall = false;
+        await fs.appendFile(state.filePath, prefix + JSON.stringify(entry) + '\n');
+      } catch (err) {
+        this.logger.error('Failed to log circuit call', { error: err });
+      }
+    }
+    return entry;
+  }
+
+  /** Closes the recording file with the trailing brackets so the JSON parses. */
+  protected override async onFinish(recording: CircuitRecording): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
+    try {
+      await fs.appendFile(state.filePath, '  ]\n}\n');
+    } catch (err) {
+      this.logger.error('Failed to finalize recording file', { error: err });
+    }
+  }
+
+  /** Closes the recording file with the execution error and trailing brackets so the JSON parses. */
+  protected override async onError(recording: CircuitRecording, error: unknown): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
+    try {
+      await fs.appendFile(state.filePath, '  ],\n');
+      await fs.appendFile(state.filePath, `  "error": ${JSON.stringify(error)}\n`);
+      await fs.appendFile(state.filePath, '}\n');
+    } catch (err) {
+      this.logger.error('Failed to finalize recording file with error', { error: err });
+    }
+  }
+}
+
+/**
+ * Generates a file path for storing circuit recordings. The format of the filename is:
+ * `circuit_name_circuit_function_name_YYYY-MM-DD_N.json` where N is a counter to ensure unique filenames.
+ * @param recordDir - Base directory for recordings
+ * @param circuitName - Name of the circuit
+ * @param functionName - Name of the circuit function
+ * @param counter - Counter to ensure unique filenames. This is expected to be incremented in a loop until there is no
+ * existing file with the same name.
+ * @returns A file path for the recording.
+ */
+function getFilePath(recordDir: string, circuitName: string, functionName: string, counter: number): string {
+  const date = new Date();
+  const formattedDate = date.toISOString().split('T')[0];
+  const filename = `${circuitName}_${functionName}_${formattedDate}_${counter}.json`;
+  return path.join(recordDir, filename);
+}

package/src/entrypoints/server/circuit_recording/memory_circuit_recorder.ts

@@ -0,0 +1,13 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+
+import { CircuitRecorder } from './circuit_recorder.js';
+
+/**
+ * In memory circuit recorder uses the default implementation. This is kept
+ * while we decide the fate of the FileCircuitRecorder.
+ */
+export class MemoryCircuitRecorder extends CircuitRecorder {
+  constructor(logger?: Logger) {
+    super(logger);
+  }
+}

package/src/entrypoints/server/circuit_recording/simulator_recorder_wrapper.ts

@@ -0,0 +1,90 @@
+import type { ForeignCallHandler } from '@aztec/noir-acvm_js';
+
+import type {
+  ACIRCallback,
+  ACIRCallbackStats,
+  ACIRExecutionResult,
+  ACVMSuccess,
+  ACVMWitness,
+  CircuitSimulator,
+} from '@aztec-labs/simulator/client';
+import type { FunctionArtifactWithContractName } from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec-labs/stdlib/noir';
+
+import type { CircuitRecorder } from './circuit_recorder.js';
+
+/**
+ * Takes a circuit simulator and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
+ * recording works.
+ */
+export class SimulatorRecorderWrapper implements CircuitSimulator {
+  constructor(
+    private simulator: CircuitSimulator,
+    private recorder: CircuitRecorder,
+  ) {}
+
+  executeProtocolCircuit(
+    input: ACVMWitness,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler | undefined,
+  ): Promise<ACVMSuccess> {
+    const bytecode = Buffer.from(artifact.bytecode, 'base64');
+
+    return this.#simulate<ForeignCallHandler | undefined, ACVMSuccess>(
+      wrappedCallback => this.simulator.executeProtocolCircuit(input, artifact, wrappedCallback),
+      input,
+      bytecode,
+      artifact.name,
+      'main',
+      callback,
+    );
+  }
+
+  executeUserCircuit(
+    input: ACVMWitness,
+    artifact: FunctionArtifactWithContractName,
+    callback: ACIRCallback,
+  ): Promise<ACIRExecutionResult> {
+    return this.#simulate<ACIRCallback, ACIRExecutionResult>(
+      wrappedCallback => this.simulator.executeUserCircuit(input, artifact, wrappedCallback),
+      input,
+      artifact.bytecode,
+      artifact.contractName,
+      artifact.name,
+      callback,
+    );
+  }
+
+  async #simulate<C extends ACIRCallback | ForeignCallHandler | undefined, T extends ACIRExecutionResult | ACVMSuccess>(
+    simulateFn: (wrappedCallback: C) => Promise<T>,
+    input: ACVMWitness,
+    bytecode: Buffer,
+    contractName: string,
+    functionName: string,
+    callback: C,
+  ): Promise<T> {
+    // If a callback was provided, we wrap it so that its oracle calls are recorded. The wrapped callback reads the
+    // active recording lazily, so it picks up the recording opened by record() below.
+    const wrappedCallback = this.recorder.wrapCallback(callback);
+
+    // record() opens a recording for this circuit, runs the simulation within it, and finalizes it. A simulation
+    // failure is re-thrown unchanged, so recorder bookkeeping never masks the underlying error.
+    const { result, recording } = await this.recorder.record(
+      { input, bytecode, circuitName: contractName, functionName },
+      () => simulateFn(wrappedCallback as C),
+    );
+
+    (result as ACIRExecutionResult).oracles = recording.oracleCalls.reduce(
+      (acc, { time, name }) => {
+        if (!acc[name]) {
+          acc[name] = { times: [] };
+        }
+        acc[name].times.push(time);
+        return acc;
+      },
+      {} as Record<string, ACIRCallbackStats>,
+    );
+
+    return result;
+  }
+}

package/src/entrypoints/server/index.ts

@@ -0,0 +1,17 @@
+export { type AccountPrivacyKeys, type AccountPrivacySecretKeys } from '@aztec-labs/key-store';
+
+export * from '../../notes_filter.js';
+export * from '../../pxe.js';
+export * from '../../config/index.js';
+export * from '../../error_enriching.js';
+export * from '../../storage/index.js';
+export * from './utils.js';
+export * from './store.js';
+export { NoteService } from '../../notes/note_service.js';
+export { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
+export { type PXECreationOptions } from '../pxe_creation_options.js';
+export { type ChangeSetId, StagedWriteCoordinator } from '../../storage/staged_write_coordinator.js';
+export { runOperation, type OperationContributor } from '../../operation_lifecycle.js';
+export { ContractSyncService } from '../../contract/contract_sync_service.js';
+export { ContractClassService } from '../../contract/contract_class_service.js';
+export { AnchoredContractData } from '../../contract_function_simulator/anchored_contract_data.js';

package/src/entrypoints/server/store.ts

@@ -0,0 +1,46 @@
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type LoggerBindings, createLogger } from '@aztec-labs/foundation/log';
+import { type AztecLMDBStoreV2, openStoreAt } from '@aztec-labs/kv-store/lmdb-v2';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+
+import { storeIdentitySlug } from '../../storage/store_identity.js';
+
+/** Location and identity inputs for opening an identity-partitioned PXE-side store. */
+export type IdentityStoreConfig = {
+  dataDirectory: string;
+  /** Maximum LMDB map size in KB. When omitted, the kv-store default map size applies. */
+  dataStoreMapSizeKb?: number;
+  l1ChainId: number;
+  rollupAddress: EthAddress;
+};
+
+/**
+ * Opens the persistent LMDB store selected by `name` and identity triple `(l1ChainId, rollupAddress, schemaVersion)`.
+ * A store exists per identity: reopening with the same identity returns the same data, a different identity selects
+ * a different (possibly fresh) store. Callers wanting an ephemeral store use `openTmpStore` explicitly instead.
+ */
+export async function openStore(
+  name: string,
+  schemaVersion: number,
+  config: IdentityStoreConfig,
+  bindings?: LoggerBindings,
+): Promise<AztecLMDBStoreV2> {
+  // Stores live under `<dataDirectory>/<name>-stores/<l1ChainId>-<rollupAddress>-v<schemaVersion>`, a sibling of the
+  // legacy `<dataDirectory>/<name>` directory: older binaries reset the legacy directory on a rollup mismatch, so
+  // per-identity stores must not nest inside it.
+  const subDir = join(
+    config.dataDirectory,
+    `${name}-stores`,
+    storeIdentitySlug({ l1ChainId: config.l1ChainId, rollupAddress: config.rollupAddress, schemaVersion }),
+  );
+  await mkdir(subDir, { recursive: true });
+
+  createLogger(`pxe:data:${name}`, bindings).info(`Opening ${name} data store (LMDB v2)`, {
+    storeName: name,
+    subDir,
+    dataStoreMapSizeKb: config.dataStoreMapSizeKb,
+  });
+
+  return openStoreAt(subDir, config.dataStoreMapSizeKb, undefined, bindings);
+}

package/src/entrypoints/server/utils.ts

@@ -0,0 +1,103 @@
+import { BBBundlePrivateKernelProver } from '@aztec-labs/bb-prover/client/bundle';
+import type { L1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { openTmpStore } from '@aztec-labs/kv-store/lmdb-v2';
+import { BundledProtocolContractsProvider } from '@aztec-labs/protocol-contracts/providers/bundle';
+import { WASMSimulator } from '@aztec-labs/simulator/client';
+import { getStandardAuthRegistry } from '@aztec-labs/standard-contracts/auth-registry';
+import { getStandardHandshakeRegistry } from '@aztec-labs/standard-contracts/handshake-registry';
+import { getStandardMultiCallEntrypoint } from '@aztec-labs/standard-contracts/multi-call-entrypoint';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+
+import type { PXEConfig } from '../../config/index.js';
+import { PXE } from '../../pxe.js';
+import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
+import { type PXECreationOptions, isPrivateKernelProver } from '../pxe_creation_options.js';
+import { FileCircuitRecorder } from './circuit_recording/file_circuit_recorder.js';
+import { MemoryCircuitRecorder } from './circuit_recording/memory_circuit_recorder.js';
+import { SimulatorRecorderWrapper } from './circuit_recording/simulator_recorder_wrapper.js';
+import { openStore } from './store.js';
+
+type PXEConfigWithoutDefaults = Omit<
+  PXEConfig,
+  'l1ChainId' | 'l2BlockBatchSize' | 'rollupVersion' | keyof L1ContractAddresses
+>;
+
+export async function createPXE(
+  aztecNode: AztecNode,
+  config: PXEConfigWithoutDefaults,
+  options: PXECreationOptions = { loggers: {} },
+) {
+  const actor = options.loggerActorLabel;
+  const recorderLogger = createLogger('simulator:acvm:recording', { actor });
+  const recorder = process.env.CIRCUIT_RECORD_DIR
+    ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR, recorderLogger)
+    : new MemoryCircuitRecorder(recorderLogger);
+  const simulatorLogger = createLogger('wasm-simulator', { actor });
+  const simulator = new SimulatorRecorderWrapper(new WASMSimulator(simulatorLogger), recorder);
+  const loggers = options.loggers ?? {};
+
+  const { l1ChainId, l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
+  const configWithContracts: PXEConfig = {
+    ...config,
+    ...l1ContractAddresses,
+    l1ChainId,
+    rollupVersion,
+    l2BlockBatchSize: 50,
+  };
+
+  if (!options.store) {
+    const storeLogger = loggers.store ?? createLogger('pxe:data:lmdb', { actor });
+    options.store = configWithContracts.dataDirectory
+      ? await openStore(
+          'pxe_data',
+          PXE_DATA_SCHEMA_VERSION,
+          {
+            dataDirectory: configWithContracts.dataDirectory,
+            dataStoreMapSizeKb: configWithContracts.dataStoreMapSizeKb,
+            l1ChainId,
+            rollupAddress: l1ContractAddresses.rollupAddress,
+          },
+          storeLogger.getBindings(),
+        )
+      : await openTmpStore(
+          'pxe_data',
+          true,
+          configWithContracts.dataStoreMapSizeKb,
+          undefined,
+          storeLogger.getBindings(),
+        );
+  }
+  const proverLogger = loggers.prover ?? createLogger('pxe:bb:native', { actor });
+
+  let prover;
+  if (isPrivateKernelProver(options.proverOrOptions)) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBBundlePrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
+
+  const protocolContractsProvider = new BundledProtocolContractsProvider();
+  const preloadedContractsProvider = options.preloadedContractsProvider ?? {
+    getPreloadedContracts: async () => [
+      await getStandardMultiCallEntrypoint(),
+      await getStandardAuthRegistry(),
+      await getStandardHandshakeRegistry(),
+    ],
+  };
+
+  const pxeLogger = loggers.pxe ?? createLogger('pxe:service', { actor });
+  const pxe = await PXE.create({
+    node: aztecNode,
+    nodeDebug: options.nodeDebug,
+    store: options.store,
+    proofCreator: prover,
+    simulator,
+    protocolContractsProvider,
+    preloadedContractsProvider,
+    config: configWithContracts,
+    loggerOrSuffix: pxeLogger,
+    hooks: options.hooks,
+  });
+  return pxe;
+}