@aztec/pxe 0.87.5 → 0.87.7

package/src/contract_function_simulator/pick_notes.ts

@@ -0,0 +1,141 @@
+import { Fr } from '@aztec/foundation/fields';
+import { Comparator, type Note } from '@aztec/stdlib/note';
+
+export interface PropertySelector {
+  index: number;
+  offset: number;
+  length: number;
+}
+
+/**
+ * Configuration for selecting values.
+ */
+export interface Select {
+  /**
+   * Selector of the field to select and match.
+   */
+  selector: PropertySelector;
+  /**
+   * Required value of the field.
+   */
+  value: Fr;
+  /**
+   * The comparator to use
+   */
+  comparator: Comparator;
+}
+
+/**
+ * The order to sort an array.
+ */
+export enum SortOrder {
+  NADA = 0,
+  DESC = 1,
+  ASC = 2,
+}
+
+/**
+ * Configuration for sorting values.
+ */
+export interface Sort {
+  /**
+   * Selector of the field to sort.
+   */
+  selector: PropertySelector;
+  /**
+   * Order to sort the field.
+   */
+  order: SortOrder;
+}
+
+/**
+ * Options for picking items from an array of BasicNoteData.
+ */
+interface GetOptions {
+  /**
+   * Configurations for selecting items.
+   * Default: empty array.
+   */
+  selects?: Select[];
+  /**
+   * Configurations for sorting items.
+   * Default: empty array.
+   */
+  sorts?: Sort[];
+  /**
+   * The number of items to retrieve per query.
+   * Default: 0. No limit.
+   */
+  limit?: number;
+  /**
+   * The starting index for pagination.
+   * Default: 0.
+   */
+  offset?: number;
+}
+
+/**
+ * Data needed from to perform sort.
+ */
+interface ContainsNote {
+  /**
+   * The note.
+   */
+  note: Note;
+}
+
+const selectPropertyFromPackedNoteContent = (noteData: Fr[], selector: PropertySelector): Fr => {
+  const noteValueBuffer = noteData[selector.index].toBuffer();
+  const noteValue = noteValueBuffer.subarray(selector.offset, selector.offset + selector.length);
+  return Fr.fromBuffer(noteValue);
+};
+
+const selectNotes = <T extends ContainsNote>(noteDatas: T[], selects: Select[]): T[] =>
+  noteDatas.filter(noteData =>
+    selects.every(({ selector, value, comparator }) => {
+      const noteValueFr = selectPropertyFromPackedNoteContent(noteData.note.items, selector);
+      const comparatorSelector = {
+        [Comparator.EQ]: () => noteValueFr.equals(value),
+        [Comparator.NEQ]: () => !noteValueFr.equals(value),
+        [Comparator.LT]: () => noteValueFr.lt(value),
+        [Comparator.LTE]: () => noteValueFr.lt(value) || noteValueFr.equals(value),
+        [Comparator.GT]: () => !noteValueFr.lt(value) && !noteValueFr.equals(value),
+        [Comparator.GTE]: () => !noteValueFr.lt(value),
+      };
+
+      return comparatorSelector[comparator]();
+    }),
+  );
+
+const sortNotes = (a: Fr[], b: Fr[], sorts: Sort[], level = 0): number => {
+  if (sorts[level] === undefined) {
+    return 0;
+  }
+
+  const { selector, order } = sorts[level];
+  if (order === (0 as SortOrder)) {
+    return 0;
+  }
+
+  const aValue = selectPropertyFromPackedNoteContent(a, selector);
+  const bValue = selectPropertyFromPackedNoteContent(b, selector);
+
+  const dir = order === (1 as SortOrder) ? [-1, 1] : [1, -1];
+  return aValue.toBigInt() === bValue.toBigInt()
+    ? sortNotes(a, b, sorts, level + 1)
+    : aValue.toBigInt() > bValue.toBigInt()
+      ? dir[0]
+      : dir[1];
+};
+
+/**
+ * Pick from a note array a number of notes that meet the criteria.
+ */
+export function pickNotes<T extends ContainsNote>(
+  noteDatas: T[],
+  { selects = [], sorts = [], limit = 0, offset = 0 }: GetOptions,
+): T[] {
+  return selectNotes(noteDatas, selects)
+    .sort((a, b) => sortNotes(a.note.items, b.note.items, sorts))
+    .slice(offset, limit ? offset + limit : undefined);
+}

package/src/contract_function_simulator/proxied_node.ts

@@ -0,0 +1,33 @@
+import { Timer } from '@aztec/foundation/timer';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { NodeStats } from '@aztec/stdlib/tx';
+
+/*
+ * Proxy for an AztecNode that tracks the time taken for each RPC call.
+ */
+export type ProxiedNode = AztecNode & { getStats(): NodeStats };
+
+export class ProxiedNodeFactory {
+  static create(node: AztecNode) {
+    const stats: Partial<Record<keyof AztecNode, { times: number[] }>> = {};
+    return new Proxy(node, {
+      get(target, prop: keyof ProxiedNode) {
+        if (prop === 'getStats') {
+          return () => {
+            return stats;
+          };
+        } else {
+          return async function (...args: any[]) {
+            if (!stats[prop]) {
+              stats[prop] = { times: [] };
+            }
+            const timer = new Timer();
+            const result = await (target[prop] as any).apply(target, args);
+            stats[prop].times.push(timer.ms());
+            return result;
+          };
+        }
+      },
+    }) as ProxiedNode;
+  }
+}

package/src/{pxe_oracle_interface → contract_function_simulator}/pxe_oracle_interface.ts

@@ -3,7 +3,6 @@ import { timesParallel } from '@aztec/foundation/collection';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { KeyStore } from '@aztec/key-store';
-import { type ExecutionDataProvider, MessageLoadOracleInputs } from '@aztec/simulator/client';
 import {
   EventSelector,
   type FunctionArtifactWithContractName,
@@ -31,6 +30,8 @@ import { MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import { TxHash } from '@aztec/stdlib/tx';
 
+import type { ExecutionDataProvider, ExecutionStats } from '../contract_function_simulator/execution_data_provider.js';
+import { MessageLoadOracleInputs } from '../contract_function_simulator/oracle/message_load_oracle_inputs.js';
 import type { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
 import type { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
 import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
@@ -39,6 +40,7 @@ import type { NoteDataProvider } from '../storage/note_data_provider/note_data_p
 import type { PrivateEventDataProvider } from '../storage/private_event_data_provider/private_event_data_provider.js';
 import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
 import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
+import type { ProxiedNode } from './proxied_node.js';
 import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 
 /**
@@ -46,7 +48,7 @@ import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndex
  */
 export class PXEOracleInterface implements ExecutionDataProvider {
   constructor(
-    private aztecNode: AztecNode,
+    private aztecNode: AztecNode | ProxiedNode,
     private keyStore: KeyStore,
     private contractDataProvider: ContractDataProvider,
     private noteDataProvider: NoteDataProvider,
@@ -151,16 +153,6 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     return new MessageLoadOracleInputs(messageIndex, siblingPath);
   }
 
-  // Only used in public.
-  public getL1ToL2MessageHash(_leafIndex: bigint): Promise<Fr | undefined> {
-    throw new Error('Unimplemented in private!');
-  }
-
-  // We need this in public as part of the EXISTS calls - but isn't used in private
-  public getNoteHash(_leafIndex: bigint): Promise<Fr | undefined> {
-    throw new Error('Unimplemented in private!');
-  }
-
   async getNullifierIndex(nullifier: Fr) {
     return await this.#findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
   }
@@ -649,12 +641,13 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     const siloedNullifier = await siloNullifier(contractAddress, nullifier);
 
     // We store notes by their index in the global note hash tree, which has the convenient side effect of validating
-    // note existence in said tree.
-    const [uniqueNoteHashTreeIndexInBlock] = await this.aztecNode.findLeavesIndexes(
-      syncedBlockNumber,
-      MerkleTreeId.NOTE_HASH_TREE,
-      [uniqueNoteHash],
-    );
+    // note existence in said tree. We concurrently also check if the note's nullifier exists, performing all node
+    // queries in a single round-trip.
+    const [[uniqueNoteHashTreeIndexInBlock], [nullifierIndex]] = await Promise.all([
+      this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash]),
+      this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [siloedNullifier]),
+    ]);
+
     if (uniqueNoteHashTreeIndexInBlock === undefined) {
       throw new Error(
         `Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${syncedBlockNumber} (from tx ${txHash})`,
@@ -684,9 +677,6 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       nullifier: noteDao.siloedNullifier.toString(),
     });
 
-    const [nullifierIndex] = await this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [
-      siloedNullifier,
-    ]);
     if (nullifierIndex !== undefined) {
       const { data: _, ...blockHashAndNum } = nullifierIndex;
       await this.noteDataProvider.removeNullifiedNotes([{ data: siloedNullifier, ...blockHashAndNum }], recipient);
@@ -832,4 +822,11 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       blockNumber,
     );
   }
+
+  getStats(): ExecutionStats {
+    const nodeRPCCalls =
+      typeof (this.aztecNode as ProxiedNode).getStats === 'function' ? (this.aztecNode as ProxiedNode).getStats() : {};
+
+    return { nodeRPCCalls };
+  }
 }

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

@@ -2,4 +2,4 @@ export * from '../../../pxe_service/index.js';
 export * from '../../../config/index.js';
 export * from '../../../storage/index.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../../pxe_oracle_interface/pxe_oracle_interface.js';
+export { PXEOracleInterface } from '../../../contract_function_simulator/pxe_oracle_interface.js';

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

@@ -1,4 +1,5 @@
 import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
+import { randomBytes } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
@@ -7,7 +8,7 @@ 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 { PXECreationOptions } from '../../pxe_creation_options.js';
 
 /**
  * Create and start an PXEService instance with the given AztecNode.
@@ -24,6 +25,15 @@ export async function createPXEService(
   config: PXEServiceConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
+  const logSuffix =
+    typeof options.useLogSuffix === 'boolean'
+      ? options.useLogSuffix
+        ? randomBytes(3).toString('hex')
+        : undefined
+      : options.useLogSuffix;
+
+  const loggers = options.loggers ?? {};
+
   const l1Contracts = await aztecNode.getL1ContractAddresses();
   const configWithContracts = {
     ...config,
@@ -31,29 +41,27 @@ export async function createPXEService(
     l2BlockBatchSize: 200,
   } as PXEServiceConfig;
 
-  const store = await createStore(
-    'pxe_data',
-    configWithContracts,
-    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
-  );
+  const storeLogger = loggers.store ? loggers.store : createLogger('pxe:data:idb' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const simulationProvider = new WASMSimulator();
-  const prover =
-    options.prover ??
-    new BBWASMBundlePrivateKernelProver(
-      simulationProvider,
-      16,
-      options.loggers.prover ?? createLogger('bb:wasm:bundle'),
-    );
+  const store = options.store ?? (await createStore('pxe_data', configWithContracts, storeLogger));
+
+  const simulator = new WASMSimulator();
+  const proverLogger = loggers.prover
+    ? loggers.prover
+    : createLogger('pxe:bb:wasm:bundle' + (logSuffix ? `:${logSuffix}` : ''));
+
+  const prover = options.prover ?? new BBWASMBundlePrivateKernelProver(simulator, 16, proverLogger);
   const protocolContractsProvider = new BundledProtocolContractsProvider();
+
+  const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
   const pxe = await PXEService.create(
     aztecNode,
     store,
     prover,
-    simulationProvider,
+    simulator,
     protocolContractsProvider,
     config,
-    options.loggers.pxe ?? createLogger('pxe:service'),
+    pxeLogger,
   );
   return pxe;
 }

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

@@ -2,4 +2,4 @@ export * from '../../../pxe_service/index.js';
 export * from '../../../config/index.js';
 export * from '../../../storage/index.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../../pxe_oracle_interface/pxe_oracle_interface.js';
+export { PXEOracleInterface } from '../../../contract_function_simulator/pxe_oracle_interface.js';

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

@@ -1,4 +1,5 @@
 import { BBWASMLazyPrivateKernelProver } from '@aztec/bb-prover/client/wasm/lazy';
+import { randomBytes } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
 import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
@@ -7,7 +8,7 @@ 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 { PXECreationOptions } from '../../pxe_creation_options.js';
 
 /**
  * Create and start an PXEService instance with the given AztecNode.
@@ -23,6 +24,13 @@ export async function createPXEService(
   config: PXEServiceConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
+  const logSuffix =
+    typeof options.useLogSuffix === 'boolean'
+      ? options.useLogSuffix
+        ? randomBytes(3).toString('hex')
+        : undefined
+      : options.useLogSuffix;
+
   const l1Contracts = await aztecNode.getL1ContractAddresses();
   const configWithContracts = {
     ...config,
@@ -30,25 +38,30 @@ export async function createPXEService(
     l1Contracts,
   } as PXEServiceConfig;
 
-  const store = await createStore(
-    'pxe_data',
-    configWithContracts,
-    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
-  );
+  const loggers = options.loggers ?? {};
+
+  const storeLogger = loggers.store ? loggers.store : createLogger('pxe:data:idb' + (logSuffix ? `:${logSuffix}` : ''));
+
+  const store = options.store ?? (await createStore('pxe_data', configWithContracts, storeLogger));
+
+  const simulator = new WASMSimulator();
+  const proverLogger = loggers.prover
+    ? loggers.prover
+    : createLogger('pxe:bb:wasm:bundle' + (logSuffix ? `:${logSuffix}` : ''));
+
+  const prover = options.prover ?? new BBWASMLazyPrivateKernelProver(simulator, 16, proverLogger);
 
-  const simulationProvider = new WASMSimulator();
-  const prover =
-    options.prover ??
-    new BBWASMLazyPrivateKernelProver(simulationProvider, 16, options.loggers.prover ?? createLogger('bb:wasm:lazy'));
   const protocolContractsProvider = new LazyProtocolContractsProvider();
+
+  const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
   const pxe = await PXEService.create(
     aztecNode,
     store,
     prover,
-    simulationProvider,
+    simulator,
     protocolContractsProvider,
     config,
-    options.loggers.pxe ?? createLogger('pxe:service'),
+    pxeLogger,
   );
   return pxe;
 }

package/src/entrypoints/{client/pxe_creation_options.ts → pxe_creation_options.ts}

@@ -1,7 +1,10 @@
 import type { Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 
 export type PXECreationOptions = {
-  loggers: { store?: Logger; pxe?: Logger; prover?: Logger };
+  loggers?: { store?: Logger; pxe?: Logger; prover?: Logger };
+  useLogSuffix?: boolean | string;
   prover?: PrivateKernelProver;
+  store?: AztecAsyncKVStore;
 };

package/src/entrypoints/server/index.ts

@@ -3,4 +3,4 @@ export * from '../../pxe_http/index.js';
 export * from '../../config/index.js';
 export * from '../../storage/index.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../pxe_oracle_interface/pxe_oracle_interface.js';
+export { PXEOracleInterface } from '../../contract_function_simulator/pxe_oracle_interface.js';

package/src/entrypoints/server/utils.ts

@@ -1,16 +1,21 @@
 import { BBNativePrivateKernelProver } from '@aztec/bb-prover/client/native';
 import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
 import { randomBytes } from '@aztec/foundation/crypto';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
-import { type SimulationProvider, WASMSimulator } from '@aztec/simulator/client';
-import { SimulationProviderRecorderWrapper } from '@aztec/simulator/testing';
+import {
+  type CircuitSimulator,
+  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 '../../storage/index.js';
+import type { PXECreationOptions } from '../pxe_creation_options.js';
 
 /**
  * Create and start an PXEService instance with the given AztecNode and config.
@@ -23,32 +28,38 @@ import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
 export function createPXEService(
   aztecNode: AztecNode,
   config: PXEServiceConfig,
-  useLogSuffix: string | boolean | undefined = undefined,
-  store?: AztecAsyncKVStore,
+  options: PXECreationOptions = { loggers: {} },
 ) {
-  const simulationProvider = new WASMSimulator();
-  const simulationProviderWithRecorder = new SimulationProviderRecorderWrapper(simulationProvider);
-  return createPXEServiceWithSimulationProvider(aztecNode, simulationProviderWithRecorder, config, useLogSuffix, store);
+  const simulator = new WASMSimulator();
+  const recorder = process.env.CIRCUIT_RECORD_DIR
+    ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR)
+    : new MemoryCircuitRecorder();
+  const simulatorWithRecorder = new SimulatorRecorderWrapper(simulator, recorder);
+  return createPXEServiceWithSimulator(aztecNode, simulatorWithRecorder, config, options);
 }
 
 /**
- * Create and start an PXEService instance with the given AztecNode, SimulationProvider and config.
+ * Create and start an PXEService instance with the given AztecNode, Simulator and config.
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
- * @param simulationProvider - The SimulationProvider to use
+ * @param simulator - The Simulator to use
  * @param config - The PXE Service Config to use
  * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
  * @returns A Promise that resolves to the started PXEService instance.
  */
-export async function createPXEServiceWithSimulationProvider(
+export async function createPXEServiceWithSimulator(
   aztecNode: AztecNode,
-  simulationProvider: SimulationProvider,
+  simulator: CircuitSimulator,
   config: PXEServiceConfig,
-  useLogSuffix: string | boolean | undefined = undefined,
-  store?: AztecAsyncKVStore,
+  options: PXECreationOptions = { loggers: {} },
 ) {
   const logSuffix =
-    typeof useLogSuffix === 'boolean' ? (useLogSuffix ? randomBytes(3).toString('hex') : undefined) : useLogSuffix;
+    typeof options.useLogSuffix === 'boolean'
+      ? options.useLogSuffix
+        ? randomBytes(3).toString('hex')
+        : undefined
+      : options.useLogSuffix;
+  const loggers = options.loggers ?? {};
 
   const l1Contracts = await aztecNode.getL1ContractAddresses();
   const configWithContracts = {
@@ -57,34 +68,41 @@ export async function createPXEServiceWithSimulationProvider(
     l2BlockBatchSize: 200,
   } as PXEServiceConfig;
 
-  if (!store) {
+  if (!options.store) {
     // TODO once https://github.com/AztecProtocol/aztec-packages/issues/13656 is fixed, we can remove this and always
     // import the lmdb-v2 version
     const { createStore } = await import('@aztec/kv-store/lmdb-v2');
-    store = await createStore('pxe_data', PXE_DATA_SCHEMA_VERSION, configWithContracts, createLogger('pxe:data:lmdb'));
+    const storeLogger = loggers.store
+      ? loggers.store
+      : createLogger('pxe:data:lmdb' + (logSuffix ? `:${logSuffix}` : ''));
+    options.store = await createStore('pxe_data', PXE_DATA_SCHEMA_VERSION, configWithContracts, storeLogger);
   }
+  const proverLogger = loggers.prover
+    ? loggers.prover
+    : createLogger('pxe:bb:native' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const prover = await createProver(config, simulationProvider, logSuffix);
+  const prover = await createProver(config, simulator, proverLogger);
   const protocolContractsProvider = new BundledProtocolContractsProvider();
+
+  const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
   const pxe = await PXEService.create(
     aztecNode,
-    store,
+    options.store,
     prover,
-    simulationProvider,
+    simulator,
     protocolContractsProvider,
     config,
-    logSuffix,
+    pxeLogger,
   );
   return pxe;
 }
 
-function createProver(config: PXEServiceConfig, simulationProvider: SimulationProvider, logSuffix?: string) {
+function createProver(config: PXEServiceConfig, simulator: CircuitSimulator, logger?: Logger) {
   if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return new BBWASMBundlePrivateKernelProver(simulationProvider, 16);
+    return new BBWASMBundlePrivateKernelProver(simulator, 16, logger);
   } 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);
+    return BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulator, logger);
   }
 }

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -115,8 +115,8 @@ export class PrivateKernelExecutionProver {
           validationRequestsSplitCounter,
         );
         while (resetBuilder.needsReset()) {
-          const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
           const witgenTimer = new Timer();
+          const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
           output = generateWitnesses
             ? await this.proofCreator.generateResetOutput(privateInputs)
             : await this.proofCreator.simulateReset(privateInputs);
@@ -154,12 +154,15 @@ export class PrivateKernelExecutionProver {
         vk: currentExecution.vk,
         timings: {
           witgen: currentExecution.profileResult?.timings.witgen ?? 0,
+          oracles: currentExecution.profileResult?.timings.oracles,
         },
       });
 
       const privateCallData = await this.createPrivateCallData(currentExecution);
 
       if (firstIteration) {
+        const witgenTimer = new Timer();
+
         const proofInput = new PrivateKernelInitCircuitPrivateInputs(
           txRequest,
           getVKTreeRoot(),
@@ -174,7 +177,6 @@ export class PrivateKernelExecutionProver {
 
         pushTestData('private-kernel-inputs-init', proofInput);
 
-        const witgenTimer = new Timer();
         output = generateWitnesses
           ? await this.proofCreator.generateInitOutput(proofInput)
           : await this.proofCreator.simulateInit(proofInput);
@@ -189,6 +191,7 @@ export class PrivateKernelExecutionProver {
           },
         });
       } else {
+        const witgenTimer = new Timer();
         const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(
           output.verificationKey.keyAsFields,
         );
@@ -201,7 +204,6 @@ export class PrivateKernelExecutionProver {
         const proofInput = new PrivateKernelInnerCircuitPrivateInputs(previousKernelData, privateCallData);
 
         pushTestData('private-kernel-inputs-inner', proofInput);
-        const witgenTimer = new Timer();
         output = generateWitnesses
           ? await this.proofCreator.generateInnerOutput(proofInput)
           : await this.proofCreator.simulateInner(proofInput);
@@ -227,8 +229,8 @@ export class PrivateKernelExecutionProver {
       validationRequestsSplitCounter,
     );
     while (resetBuilder.needsReset()) {
-      const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
       const witgenTimer = new Timer();
+      const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
       output = generateWitnesses
         ? await this.proofCreator.generateResetOutput(privateInputs)
         : await this.proofCreator.simulateReset(privateInputs);