@aztec/pxe 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/contract_function_simulator/proxied_contract_data_source.ts

@@ -0,0 +1,83 @@
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractOverrides } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/*
+ * Proxy generator for a ContractStore that allows overriding contract instances and artifacts, so
+ * the contract function simulator can execute different bytecode on certain addresses. An example use case
+ * would be overriding your own account contract so that valid signatures don't have to be provided while simulating.
+ */
+export class ProxiedContractStoreFactory {
+  static create(contractStore: ContractStore, overrides?: ContractOverrides) {
+    if (!overrides) {
+      return contractStore;
+    }
+
+    return new Proxy(contractStore, {
+      get(target, prop: keyof ContractStore) {
+        switch (prop) {
+          case 'getContractInstance': {
+            return async (address: AztecAddress) => {
+              if (overrides[address.toString()]) {
+                const { instance } = overrides[address.toString()]!;
+                instance.address = address;
+                const realInstance = await target.getContractInstance(address);
+                if (!realInstance) {
+                  throw new Error(`Contract instance not found for address: ${address}`);
+                }
+                instance.currentContractClassId = realInstance.currentContractClassId;
+                instance.originalContractClassId = realInstance.originalContractClassId;
+                return instance;
+              } else {
+                return target.getContractInstance(address);
+              }
+            };
+          }
+          case 'getFunctionArtifact': {
+            return async (contractAddress: AztecAddress, selector: FunctionSelector) => {
+              if (overrides[contractAddress.toString()]) {
+                const { artifact } = overrides[contractAddress.toString()]!;
+                const functions = artifact.functions;
+                for (let i = 0; i < functions.length; i++) {
+                  const fn = functions[i];
+                  const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
+                  if (fnSelector.equals(selector)) {
+                    return fn;
+                  }
+                }
+              } else {
+                return target.getFunctionArtifact(contractAddress, selector);
+              }
+            };
+          }
+          case 'getFunctionArtifactWithDebugMetadata': {
+            return async (contractAddress: AztecAddress, selector: FunctionSelector) => {
+              if (overrides[contractAddress.toString()]) {
+                const { artifact } = overrides[contractAddress.toString()]!;
+                const functions = artifact.functions;
+                for (let i = 0; i < functions.length; i++) {
+                  const fn = functions[i];
+                  const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
+                  if (fnSelector.equals(selector)) {
+                    return fn;
+                  }
+                }
+              } else {
+                return target.getFunctionArtifactWithDebugMetadata(contractAddress, selector);
+              }
+            };
+          }
+          default: {
+            const value = Reflect.get(target, prop);
+            if (typeof value === 'function') {
+              return value.bind(target);
+            }
+            return value;
+          }
+        }
+      },
+    });
+  }
+}

package/src/contract_sync/index.ts

@@ -0,0 +1,98 @@
+import { ProtocolContractAddress, isProtocolContract } from '@aztec/protocol-contracts';
+import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstance } from '@aztec/stdlib/contract';
+import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/**
+ * Read the current class id of a contract from the execution data provider or AztecNode. If not found, class id
+ * from the instance is used.
+ * @param contractAddress - The address of the contract to read the class id for.
+ * @param instance - The instance of the contract.
+ * @param aztecNode - The Aztec node to query for storage.
+ * @param header - The header of the block at which to load the DelayedPublicMutable storing the class id.
+ * @returns The current class id.
+ */
+export async function readCurrentClassId(
+  contractAddress: AztecAddress,
+  instance: ContractInstance,
+  aztecNode: AztecNode,
+  header: BlockHeader,
+) {
+  const blockHash = await header.hash();
+  const timestamp = header.globalVariables.timestamp;
+  const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
+  const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, slot =>
+    aztecNode.getPublicStorageAt(blockHash, ProtocolContractAddress.ContractInstanceRegistry, slot),
+  );
+  let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
+  if (currentClassId.isZero()) {
+    currentClassId = instance.originalContractClassId;
+  }
+  return currentClassId;
+}
+
+export async function syncState(
+  contractAddress: AztecAddress,
+  contractStore: ContractStore,
+  functionToInvokeAfterSync: FunctionSelector | null,
+  utilityExecutor: (privateSyncCall: FunctionCall) => Promise<any>,
+) {
+  // Protocol contracts don't have private state to sync
+  if (!isProtocolContract(contractAddress)) {
+    const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [], contractAddress);
+    if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncStateFunctionCall.selector)) {
+      throw new Error(
+        'Forbidden `sync_state` invocation. `sync_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
+      );
+    }
+
+    return utilityExecutor(syncStateFunctionCall);
+  }
+}
+
+/**
+ * Verify that the current class id of a contract obtained from AztecNode is the same as the one in contract data
+ * provider (i.e. PXE's own storage).
+ * @param header - The header of the block at which to verify the current class id.
+ */
+async function verifyCurrentClassId(
+  contractAddress: AztecAddress,
+  aztecNode: AztecNode,
+  contractStore: ContractStore,
+  header: BlockHeader,
+) {
+  const instance = await contractStore.getContractInstance(contractAddress);
+  if (!instance) {
+    throw new Error(`No contract instance found for address ${contractAddress.toString()}`);
+  }
+
+  const currentClassId = await readCurrentClassId(contractAddress, instance, aztecNode, header);
+  if (!instance.currentContractClassId.equals(currentClassId)) {
+    throw new Error(
+      `Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`,
+    );
+  }
+}
+
+/**
+ * Ensures the contract's private state is synchronized and that the PXE holds the current class artifact for
+ * the contract.
+ */
+export async function ensureContractSynced(
+  contractAddress: AztecAddress,
+  functionToInvokeAfterSync: FunctionSelector | null,
+  utilityExecutor: (call: FunctionCall) => Promise<any>,
+  aztecNode: AztecNode,
+  contractStore: ContractStore,
+  header: BlockHeader,
+): Promise<void> {
+  await Promise.all([
+    syncState(contractAddress, contractStore, functionToInvokeAfterSync, utilityExecutor),
+    verifyCurrentClassId(contractAddress, aztecNode, contractStore, header),
+  ]);
+}

package/src/debug/pxe_debug_utils.ts

@@ -0,0 +1,63 @@
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import type { NoteDao, NotesFilter } from '@aztec/stdlib/note';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { BlockSynchronizer } from '../block_synchronizer/block_synchronizer.js';
+import type { PXE } from '../pxe.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { AnchorBlockStore } from '../storage/index.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
+
+/**
+ * Methods provided by this class might help debugging but must not be used in production.
+ * No backwards compatibility or API stability should be expected. Use at your own risk.
+ */
+export class PXEDebugUtils {
+  #pxe!: PXE;
+  #putJobInQueue!: <T>(job: (jobId: string) => Promise<T>) => Promise<T>;
+
+  constructor(
+    private contractStore: ContractStore,
+    private noteStore: NoteStore,
+    private blockStateSynchronizer: BlockSynchronizer,
+    private anchorBlockStore: AnchorBlockStore,
+  ) {}
+
+  /** Not injected through constructor since they're are co-dependant */
+  public setPXE(pxe: PXE, putJobInQueue: <T>(job: (jobId: string) => Promise<T>) => Promise<T>) {
+    this.#pxe = pxe;
+    this.#putJobInQueue = putJobInQueue;
+  }
+
+  /**
+   * A debugging utility to get notes based on the provided filter.
+   *
+   * Note that this should not be used in production code because the structure of notes is considered to be
+   * an implementation detail of contracts. This is only meant to be used for debugging purposes. If you need to obtain
+   * note-related information in production code, please implement a custom utility function on your contract and call
+   * that function instead (e.g. `get_balance(owner: AztecAddress) -> u128` utility function on a Token contract).
+   *
+   * @param filter - The filter to apply to the notes.
+   * @returns The requested notes.
+   */
+  public async getNotes(filter: NotesFilter): Promise<NoteDao[]> {
+    // We need to manually trigger private state sync to have a guarantee that all the notes are available.
+    const call = await this.contractStore.getFunctionCall('sync_state', [], filter.contractAddress);
+    await this.#pxe.simulateUtility(call);
+
+    return this.noteStore.getNotes(filter, randomBytes(8).toString('hex'));
+  }
+
+  /** Returns the block header up to which the PXE has synced. */
+  public getSyncedBlockHeader(): Promise<BlockHeader> {
+    return this.anchorBlockStore.getBlockHeader();
+  }
+
+  /**
+   * Triggers a sync of the PXE with the node.
+   * Blocks until the sync is complete.
+   */
+  public sync(): Promise<void> {
+    return this.#putJobInQueue(() => this.blockStateSynchronizer.sync());
+  }
+}

package/src/entrypoints/client/bundle/index.ts

@@ -1,5 +1,6 @@
-export * from '../../../pxe_service/index.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 { PXEOracleInterface } from '../../../pxe_oracle_interface/index.js';
+export type { PXECreationOptions } from '../../pxe_creation_options.js';

package/src/entrypoints/client/bundle/utils.ts

@@ -1,58 +1,57 @@
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
+import { BBPrivateKernelProver } from '@aztec/bb-prover/client';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { WASMSimulator } from '@aztec/simulator/client';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
-import type { PXEServiceConfig } from '../../../config/index.js';
-import { PXEService } from '../../../pxe_service/pxe_service.js';
-import type { PXECreationOptions } from '../pxe_creation_options.js';
+import type { PXEConfig } from '../../../config/index.js';
+import { PXE } from '../../../pxe.js';
+import { PXE_DATA_SCHEMA_VERSION } from '../../../storage/metadata.js';
+import type { PXECreationOptions } from '../../pxe_creation_options.js';
 
 /**
- * Create and start an PXEService instance with the given AztecNode.
+ * Create and start an PXE instance with the given AztecNode.
  * If no keyStore or database is provided, it will use KeyStore and MemoryDB as default values.
- * Returns a Promise that resolves to the started PXEService instance.
+ * Returns a Promise that resolves to the started PXE instance.
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
- * @param options - (Optional) Optional information for creating an PXEService.
- * @returns A Promise that resolves to the started PXEService instance.
+ * @param config - The PXE Config to use
+ * @param options - (Optional) Optional information for creating an PXE.
+ * @returns A Promise that resolves to the started PXE instance.
  */
-export async function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
-  config: PXEServiceConfig,
+  config: PXEConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
+  const actor = options.loggerActorLabel;
+  const loggers = options.loggers ?? {};
+
   const l1Contracts = await aztecNode.getL1ContractAddresses();
   const configWithContracts = {
     ...config,
     l1Contracts,
-  } as PXEServiceConfig;
-
-  const store = await createStore(
-    'pxe_data',
-    configWithContracts,
-    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
-  );
-
-  const simulationProvider = new WASMSimulator();
-  const prover =
-    options.prover ??
-    new BBWASMBundlePrivateKernelProver(
-      simulationProvider,
-      16,
-      options.loggers.prover ?? createLogger('bb:wasm:bundle'),
-    );
+  } as PXEConfig;
+
+  const storeLogger = loggers.store ?? createLogger('pxe:data:idb', { actor });
+
+  const store =
+    options.store ?? (await createStore('pxe_data', configWithContracts, PXE_DATA_SCHEMA_VERSION, storeLogger));
+
+  const simulator = options.simulator ?? new WASMSimulator();
+  const proverLogger = loggers.prover ?? createLogger('pxe:bb:wasm:bundle', { actor });
+
+  let prover;
+  if (options.proverOrOptions instanceof BBPrivateKernelProver) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBBundlePrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
   const protocolContractsProvider = new BundledProtocolContractsProvider();
-  const pxe = await PXEService.create(
-    aztecNode,
-    store,
-    prover,
-    simulationProvider,
-    protocolContractsProvider,
-    config,
-    options.loggers.pxe ?? createLogger('pxe:service'),
-  );
+
+  const pxeLogger = loggers.pxe ?? createLogger('pxe:service', { actor });
+  const pxe = await PXE.create(aztecNode, store, prover, simulator, protocolContractsProvider, config, pxeLogger);
   return pxe;
 }

package/src/entrypoints/client/lazy/index.ts

@@ -1,5 +1,6 @@
-export * from '../../../pxe_service/index.js';
+export * from '../../../pxe.js';
 export * from '../../../config/index.js';
 export * from '../../../storage/index.js';
+export * from '../../../error_enriching.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../../pxe_oracle_interface/index.js';
+export { type PXECreationOptions } from '../../pxe_creation_options.js';

package/src/entrypoints/client/lazy/utils.ts

@@ -1,53 +1,57 @@
-import { BBWASMLazyPrivateKernelProver } from '@aztec/bb-prover/wasm/lazy';
+import { BBPrivateKernelProver } from '@aztec/bb-prover/client';
+import { BBLazyPrivateKernelProver } from '@aztec/bb-prover/client/lazy';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
 import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
 import { WASMSimulator } from '@aztec/simulator/client';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
-import type { PXEServiceConfig } from '../../../config/index.js';
-import { PXEService } from '../../../pxe_service/pxe_service.js';
-import type { PXECreationOptions } from '../pxe_creation_options.js';
+import type { PXEConfig } from '../../../config/index.js';
+import { PXE } from '../../../pxe.js';
+import { PXE_DATA_SCHEMA_VERSION } from '../../../storage/metadata.js';
+import type { PXECreationOptions } from '../../pxe_creation_options.js';
 
 /**
- * Create and start an PXEService instance with the given AztecNode.
- * Returns a Promise that resolves to the started PXEService instance.
+ * Create and start an PXE instance with the given AztecNode.
+ * Returns a Promise that resolves to the started PXE instance.
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
- * @param
- * @returns A Promise that resolves to the started PXEService instance.
+ * @param config - The PXE Config to use
+ * @param options - (Optional) Optional information for creating an PXE.
+ * @returns A Promise that resolves to the started PXE instance.
  */
-export async function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
-  config: PXEServiceConfig,
+  config: PXEConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
+  const actor = options.loggerActorLabel;
+
   const l1Contracts = await aztecNode.getL1ContractAddresses();
   const configWithContracts = {
     ...config,
     l1Contracts,
-  } as PXEServiceConfig;
-
-  const store = await createStore(
-    'pxe_data',
-    configWithContracts,
-    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
-  );
-
-  const simulationProvider = new WASMSimulator();
-  const prover =
-    options.prover ??
-    new BBWASMLazyPrivateKernelProver(simulationProvider, 16, options.loggers.prover ?? createLogger('bb:wasm:lazy'));
+  } as PXEConfig;
+
+  const loggers = options.loggers ?? {};
+
+  const storeLogger = loggers.store ?? createLogger('pxe:data:idb', { actor });
+
+  const store =
+    options.store ?? (await createStore('pxe_data', configWithContracts, PXE_DATA_SCHEMA_VERSION, storeLogger));
+
+  const simulator = options.simulator ?? new WASMSimulator();
+  const proverLogger = loggers.prover ?? createLogger('pxe:bb:wasm:bundle', { actor });
+
+  let prover;
+  if (options.proverOrOptions instanceof BBPrivateKernelProver) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBLazyPrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
   const protocolContractsProvider = new LazyProtocolContractsProvider();
-  const pxe = await PXEService.create(
-    aztecNode,
-    store,
-    prover,
-    simulationProvider,
-    protocolContractsProvider,
-    config,
-    options.loggers.pxe ?? createLogger('pxe:service'),
-  );
+
+  const pxeLogger = loggers.pxe ?? createLogger('pxe:service', { actor });
+  const pxe = await PXE.create(aztecNode, store, prover, simulator, protocolContractsProvider, config, pxeLogger);
   return pxe;
 }

package/src/entrypoints/pxe_creation_options.ts

@@ -0,0 +1,14 @@
+import type { BBPrivateKernelProverOptions } from '@aztec/bb-prover/client';
+import type { Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { CircuitSimulator } from '@aztec/simulator/client';
+import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+
+export type PXECreationOptions = {
+  loggers?: { store?: Logger; pxe?: Logger; prover?: Logger };
+  /** Actor label to include in log output (e.g., 'pxe-0', 'pxe-test'). */
+  loggerActorLabel?: string;
+  proverOrOptions?: PrivateKernelProver | BBPrivateKernelProverOptions;
+  store?: AztecAsyncKVStore;
+  simulator?: CircuitSimulator;
+};

package/src/entrypoints/server/index.ts

@@ -1,6 +1,10 @@
-export * from '../../pxe_service/index.js';
-export * from '../../pxe_http/index.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 { PXEOracleInterface } from '../../pxe_oracle_interface/index.js';
+export { NoteService } from '../../notes/note_service.js';
+export { ORACLE_VERSION } from '../../oracle_version.js';
+export { type PXECreationOptions } from '../pxe_creation_options.js';
+export { JobCoordinator } from '../../job_coordinator/job_coordinator.js';
+export { syncState } from '../../contract_sync/index.js';

package/src/entrypoints/server/utils.ts

@@ -1,71 +1,71 @@
-import { BBNativePrivateKernelProver } from '@aztec/bb-prover';
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { BBPrivateKernelProver } from '@aztec/bb-prover/client';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
-import { type SimulationProvider, WASMSimulator } from '@aztec/simulator/client';
-import type { AztecNode, PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+import { MemoryCircuitRecorder, SimulatorRecorderWrapper, WASMSimulator } from '@aztec/simulator/client';
+import { FileCircuitRecorder } from '@aztec/simulator/testing';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
-import type { PXEServiceConfig } from '../../config/index.js';
-import { PXEService } from '../../pxe_service/pxe_service.js';
-import { PXE_DATA_SCHEMA_VERSION } from './index.js';
+import type { PXEConfig } from '../../config/index.js';
+import { PXE } from '../../pxe.js';
+import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
+import type { PXECreationOptions } from '../pxe_creation_options.js';
 
-/**
- * Create and start an PXEService instance with the given AztecNode.
- * If no keyStore or database is provided, it will use KeyStore and MemoryDB as default values.
- * Returns a Promise that resolves to the started PXEService instance.
- *
- * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
- * @param useLogSuffix - (Optional) Log suffix for PXE's logger.
- * @param proofCreator - An optional proof creator to use in place of any other configuration
- * @returns A Promise that resolves to the started PXEService instance.
- */
-export async function createPXEService(
+type PXEConfigWithoutDefaults = Omit<PXEConfig, 'l1Contracts' | 'l1ChainId' | 'l2BlockBatchSize' | 'rollupVersion'>;
+
+export async function createPXE(
   aztecNode: AztecNode,
-  config: PXEServiceConfig,
-  useLogSuffix: string | boolean | undefined = undefined,
-  proofCreator?: PrivateKernelProver,
+  config: PXEConfigWithoutDefaults,
+  options: PXECreationOptions = { loggers: {} },
 ) {
-  const logSuffix =
-    typeof useLogSuffix === 'boolean' ? (useLogSuffix ? randomBytes(3).toString('hex') : undefined) : useLogSuffix;
+  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 l1Contracts = await aztecNode.getL1ContractAddresses();
-  const configWithContracts = {
+  const { l1ChainId, l1ContractAddresses: l1Contracts, rollupVersion } = await aztecNode.getNodeInfo();
+  const configWithContracts: PXEConfig = {
     ...config,
     l1Contracts,
-  } as PXEServiceConfig;
+    l1ChainId,
+    rollupVersion,
+    l2BlockBatchSize: 50,
+  };
 
-  const store = await createStore(
-    'pxe_data',
-    PXE_DATA_SCHEMA_VERSION,
-    configWithContracts,
-    createLogger('pxe:data:lmdb'),
-  );
+  if (!options.store) {
+    const storeLogger = loggers.store ?? createLogger('pxe:data:lmdb', { actor });
+    options.store = await createStore(
+      'pxe_data',
+      PXE_DATA_SCHEMA_VERSION,
+      configWithContracts,
+      storeLogger.getBindings(),
+    );
+  }
+  const proverLogger = loggers.prover ?? createLogger('pxe:bb:native', { actor });
+
+  let prover;
+  if (options.proverOrOptions instanceof BBPrivateKernelProver) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBBundlePrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
 
-  const simulationProvider = new WASMSimulator();
-  const prover = proofCreator ?? (await createProver(config, simulationProvider, logSuffix));
   const protocolContractsProvider = new BundledProtocolContractsProvider();
-  const pxe = await PXEService.create(
+
+  const pxeLogger = loggers.pxe ?? createLogger('pxe:service', { actor });
+  const pxe = await PXE.create(
     aztecNode,
-    store,
+    options.store,
     prover,
-    simulationProvider,
+    simulator,
     protocolContractsProvider,
-    config,
-    logSuffix,
+    configWithContracts,
+    pxeLogger,
   );
   return pxe;
 }
-
-function createProver(config: PXEServiceConfig, simulationProvider: SimulationProvider, logSuffix?: string) {
-  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return new BBWASMBundlePrivateKernelProver(simulationProvider, 16);
-  } else {
-    const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> &
-      PXEServiceConfig;
-    const log = createLogger('pxe:bb-native-prover' + (logSuffix ? `:${logSuffix}` : ''));
-    return BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulationProvider, log);
-  }
-}