@aztec/pxe 0.69.0-devnet → 0.69.1-devnet

package/src/kernel_prover/kernel_prover.ts

@@ -10,6 +10,7 @@ import {
 } from '@aztec/circuit-types';
 import {
   CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  ClientIvcProof,
   Fr,
   PROTOCOL_CONTRACT_TREE_HEIGHT,
   PrivateCallData,
@@ -32,7 +33,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { Timer } from '@aztec/foundation/timer';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/client';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
 import {
   getProtocolContractSiblingPath,
   isProtocolContract,
@@ -89,6 +90,12 @@ const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicI
   bytecode: Buffer.from([]),
 };
 
+export type ProvingConfig = {
+  simulate: boolean;
+  profile: boolean;
+  dryRun: boolean;
+};
+
 /**
  * The KernelProver class is responsible for generating kernel proofs.
  * It takes a transaction request, its signature, and the simulation result as inputs, and outputs a proof
@@ -98,7 +105,11 @@ const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicI
 export class KernelProver {
   private log = createLogger('pxe:kernel-prover');
 
-  constructor(private oracle: ProvingDataOracle, private proofCreator: PrivateKernelProver) {}
+  constructor(
+    private oracle: ProvingDataOracle,
+    private proofCreator: PrivateKernelProver,
+    private fakeProofs = false,
+  ) {}
 
   /**
    * Generate a proof for a given transaction request and execution result.
@@ -116,9 +127,14 @@ export class KernelProver {
   async prove(
     txRequest: TxRequest,
     executionResult: PrivateExecutionResult,
-    profile: boolean = false,
-    dryRun: boolean = false,
+    { simulate, profile, dryRun }: ProvingConfig = { simulate: false, profile: false, dryRun: false },
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (simulate && profile) {
+      throw new Error('Cannot simulate and profile at the same time');
+    }
+
+    simulate = simulate || this.fakeProofs;
+
     const timer = new Timer();
 
     const isPrivateOnlyTx = this.isPrivateOnly(executionResult);
@@ -156,7 +172,9 @@ export class KernelProver {
         );
         while (resetBuilder.needsReset()) {
           const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
-          output = await this.proofCreator.simulateProofReset(privateInputs);
+          output = simulate
+            ? await this.proofCreator.simulateReset(privateInputs)
+            : await this.proofCreator.generateResetOutput(privateInputs);
           // TODO(#7368) consider refactoring this redundant bytecode pushing
           acirs.push(output.bytecode);
           witnessStack.push(output.outputWitness);
@@ -203,7 +221,9 @@ export class KernelProver {
 
         pushTestData('private-kernel-inputs-init', proofInput);
 
-        output = await this.proofCreator.simulateProofInit(proofInput);
+        output = simulate
+          ? await this.proofCreator.simulateInit(proofInput)
+          : await this.proofCreator.generateInitOutput(proofInput);
 
         acirs.push(output.bytecode);
         witnessStack.push(output.outputWitness);
@@ -222,7 +242,9 @@ export class KernelProver {
 
         pushTestData('private-kernel-inputs-inner', proofInput);
 
-        output = await this.proofCreator.simulateProofInner(proofInput);
+        output = simulate
+          ? await this.proofCreator.simulateInner(proofInput)
+          : await this.proofCreator.generateInnerOutput(proofInput);
 
         acirs.push(output.bytecode);
         witnessStack.push(output.outputWitness);
@@ -242,7 +264,9 @@ export class KernelProver {
     );
     while (resetBuilder.needsReset()) {
       const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
-      output = await this.proofCreator.simulateProofReset(privateInputs);
+      output = simulate
+        ? await this.proofCreator.simulateReset(privateInputs)
+        : await this.proofCreator.generateResetOutput(privateInputs);
 
       acirs.push(output.bytecode);
       witnessStack.push(output.outputWitness);
@@ -275,7 +299,9 @@ export class KernelProver {
 
     pushTestData('private-kernel-inputs-ordering', privateInputs);
 
-    const tailOutput = await this.proofCreator.simulateProofTail(privateInputs);
+    const tailOutput = simulate
+      ? await this.proofCreator.simulateTail(privateInputs)
+      : await this.proofCreator.generateTailOutput(privateInputs);
     if (tailOutput.publicInputs.forPublic) {
       const privateLogs = privateInputs.previousKernel.publicInputs.end.privateLogs;
       const nonRevertiblePrivateLogs = tailOutput.publicInputs.forPublic.nonRevertibleAccumulatedData.privateLogs;
@@ -290,12 +316,16 @@ export class KernelProver {
       tailOutput.profileResult = { gateCounts };
     }
 
-    this.log.verbose(`Private kernel witness generation took ${timer.ms()}ms`);
+    if (!simulate) {
+      this.log.info(`Private kernel witness generation took ${timer.ms()}ms`);
+    }
 
     // TODO(#7368) how do we 'bincode' encode these inputs?
-    if (!dryRun) {
+    if (!dryRun && !simulate) {
       const ivcProof = await this.proofCreator.createClientIvcProof(acirs, witnessStack);
       tailOutput.clientIvcProof = ivcProof;
+    } else {
+      tailOutput.clientIvcProof = ClientIvcProof.empty();
     }
 
     return tailOutput;

package/src/note_decryption_utils/brute_force_note_info.ts

@@ -34,6 +34,7 @@ export async function bruteForceNoteInfo(
   simulator: AcirSimulator,
   uniqueNoteHashes: Fr[],
   txHash: TxHash,
+  firstNullifier: Fr,
   contractAddress: AztecAddress,
   storageSlot: Fr,
   noteTypeId: NoteSelector,
@@ -46,7 +47,6 @@ export async function bruteForceNoteInfo(
   let noteHash: Fr | undefined;
   let uniqueNoteHash: Fr | undefined;
   let innerNullifier: Fr | undefined;
-  const firstNullifier = Fr.fromBuffer(txHash.toBuffer());
 
   for (; noteHashIndex < uniqueNoteHashes.length; ++noteHashIndex) {
     if (excludedIndices.has(noteHashIndex)) {

package/src/note_decryption_utils/produce_note_daos.ts

@@ -3,7 +3,7 @@ import { type Fr } from '@aztec/foundation/fields';
 import { type Logger } from '@aztec/foundation/log';
 import { type AcirSimulator } from '@aztec/simulator/client';
 
-import { IncomingNoteDao } from '../database/incoming_note_dao.js';
+import { NoteDao } from '../database/note_dao.js';
 import { type PxeDatabase } from '../database/pxe_database.js';
 import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
 
@@ -31,37 +31,39 @@ export async function produceNoteDaos(
   addressPoint: PublicKey | undefined,
   payload: L1NotePayload,
   txHash: TxHash,
+  firstNullifier: Fr,
   l2BlockNumber: number,
   l2BlockHash: string,
   noteHashes: Fr[],
   dataStartIndexForTx: number,
   excludedIndices: Set<number>,
   logger: Logger,
-): Promise<{ incomingNote: IncomingNoteDao | undefined }> {
+): Promise<{ note: NoteDao | undefined }> {
   if (!addressPoint) {
     throw new Error('addressPoint is undefined. Cannot create note.');
   }
 
-  let incomingNote: IncomingNoteDao | undefined;
+  let note: NoteDao | undefined;
 
   if (addressPoint) {
-    incomingNote = await produceNoteDaosForKey(
+    note = await produceNoteDaosForKey(
       simulator,
       db,
       addressPoint,
       payload,
       txHash,
+      firstNullifier,
       l2BlockNumber,
       l2BlockHash,
       noteHashes,
       dataStartIndexForTx,
       excludedIndices,
       logger,
-      IncomingNoteDao.fromPayloadAndNoteInfo,
+      NoteDao.fromPayloadAndNoteInfo,
     );
   }
 
   return {
-    incomingNote,
+    note,
   };
 }

package/src/note_decryption_utils/produce_note_daos_for_key.ts

@@ -13,6 +13,7 @@ export async function produceNoteDaosForKey<T>(
   pkM: PublicKey,
   payload: L1NotePayload,
   txHash: TxHash,
+  firstNullifier: Fr,
   l2BlockNumber: number,
   l2BlockHash: string,
   noteHashes: Fr[],
@@ -39,6 +40,7 @@ export async function produceNoteDaosForKey<T>(
       simulator,
       noteHashes,
       txHash,
+      firstNullifier,
       payload.contractAddress,
       payload.storageSlot,
       payload.noteTypeId,

package/src/pxe_service/pxe_service.ts

@@ -7,11 +7,11 @@ import {
   type FunctionCall,
   type GetUnencryptedLogsResponse,
   type InBlock,
-  type IncomingNotesFilter,
   L1EventPayload,
   type L2Block,
   type LogFilter,
   MerkleTreeId,
+  type NotesFilter,
   type PXE,
   type PXEInfo,
   type PrivateExecutionResult,
@@ -54,6 +54,7 @@ import {
   EventSelector,
   FunctionSelector,
   FunctionType,
+  decodeFunctionSignature,
   encodeArguments,
 } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
@@ -71,11 +72,10 @@ import { inspect } from 'util';
 import { type PXEServiceConfig } from '../config/index.js';
 import { getPackageInfo } from '../config/package_info.js';
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
-import { IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
+import { NoteDao } from '../database/note_dao.js';
 import { KernelOracle } from '../kernel_oracle/index.js';
-import { KernelProver } from '../kernel_prover/kernel_prover.js';
-import { TestPrivateKernelProver } from '../kernel_prover/test/test_circuit_prover.js';
+import { KernelProver, type ProvingConfig } from '../kernel_prover/kernel_prover.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { Synchronizer } from '../synchronizer/index.js';
 import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
@@ -89,6 +89,7 @@ export class PXEService implements PXE {
   private simulator: AcirSimulator;
   private log: Logger;
   private packageVersion: string;
+  private proverEnabled: boolean;
 
   constructor(
     private keyStore: KeyStore,
@@ -104,6 +105,7 @@ export class PXEService implements PXE {
     this.contractDataOracle = new ContractDataOracle(db);
     this.simulator = getAcirSimulator(db, node, keyStore, this.contractDataOracle);
     this.packageVersion = getPackageInfo().version;
+    this.proverEnabled = !!config.proverEnabled;
   }
 
   /**
@@ -237,14 +239,10 @@ export class PXEService implements PXE {
 
       await this.db.addContractArtifact(contractClassId, artifact);
 
-      const functionNames: Record<string, string> = {};
-      for (const fn of artifact.functions) {
-        if (fn.functionType === FunctionType.PUBLIC) {
-          functionNames[FunctionSelector.fromNameAndParameters(fn.name, fn.parameters).toString()] = fn.name;
-        }
-      }
-
-      await this.node.registerContractFunctionNames(instance.address, functionNames);
+      const publicFunctionSignatures = artifact.functions
+        .filter(fn => fn.functionType === FunctionType.PUBLIC)
+        .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
+      await this.node.registerContractFunctionSignatures(instance.address, publicFunctionSignatures);
 
       // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
       await this.node.addContractClass({ ...contractClass, privateFunctions: [], unconstrainedFunctions: [] });
@@ -273,8 +271,8 @@ export class PXEService implements PXE {
     return await this.node.getPublicStorageAt(contract, slot, 'latest');
   }
 
-  public async getIncomingNotes(filter: IncomingNotesFilter): Promise<UniqueNote[]> {
-    const noteDaos = await this.db.getIncomingNotes(filter);
+  public async getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
+    const noteDaos = await this.db.getNotes(filter);
 
     const extendedNotes = noteDaos.map(async dao => {
       let owner = filter.owner;
@@ -343,19 +341,19 @@ export class PXEService implements PXE {
       }
 
       await this.db.addNote(
-        new IncomingNoteDao(
+        new NoteDao(
           note.note,
           note.contractAddress,
           note.storageSlot,
-          note.noteTypeId,
-          note.txHash,
-          l2BlockNumber,
-          l2BlockHash,
           nonce,
           noteHash,
           siloedNullifier,
+          note.txHash,
+          l2BlockNumber,
+          l2BlockHash,
           index,
           owner.address.toAddressPoint(),
+          note.noteTypeId,
         ),
         scope,
       );
@@ -388,19 +386,19 @@ export class PXEService implements PXE {
       }
 
       await this.db.addNullifiedNote(
-        new IncomingNoteDao(
+        new NoteDao(
           note.note,
           note.contractAddress,
           note.storageSlot,
-          note.noteTypeId,
-          note.txHash,
-          l2BlockNumber,
-          l2BlockHash,
           nonce,
           noteHash,
           Fr.ZERO, // We are not able to derive
+          note.txHash,
+          l2BlockNumber,
+          l2BlockHash,
           index,
           note.owner.toAddressPoint(),
+          note.noteTypeId,
         ),
       );
     }
@@ -456,20 +454,16 @@ export class PXEService implements PXE {
     return await this.node.getCurrentBaseFees();
   }
 
-  async #simulateKernels(
-    txRequest: TxExecutionRequest,
-    privateExecutionResult: PrivateExecutionResult,
-  ): Promise<PrivateKernelTailCircuitPublicInputs> {
-    const result = await this.#prove(txRequest, new TestPrivateKernelProver(), privateExecutionResult);
-    return result.publicInputs;
-  }
-
   public async proveTx(
     txRequest: TxExecutionRequest,
     privateExecutionResult: PrivateExecutionResult,
   ): Promise<TxProvingResult> {
     try {
-      const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult);
+      const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+        simulate: false,
+        profile: false,
+        dryRun: false,
+      });
       return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
     } catch (err: any) {
       throw this.contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
@@ -504,17 +498,11 @@ export class PXEService implements PXE {
       await this.synchronizer.sync();
       const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
 
-      let publicInputs: PrivateKernelTailCircuitPublicInputs;
-      let profileResult;
-      if (profile) {
-        ({ publicInputs, profileResult } = await this.#profileKernelProver(
-          txRequest,
-          this.proofCreator,
-          privateExecutionResult,
-        ));
-      } else {
-        publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
-      }
+      const { publicInputs, profileResult } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+        simulate: !profile,
+        profile,
+        dryRun: true,
+      });
 
       const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
       const simulatedTx = privateSimulationResult.toSimulatedTx();
@@ -529,8 +517,8 @@ export class PXEService implements PXE {
         }
       }
 
-      this.log.info(`Simulation completed for ${simulatedTx.tryGetTxHash()} in ${timer.ms()}ms`, {
-        txHash: simulatedTx.tryGetTxHash(),
+      this.log.info(`Simulation completed for ${simulatedTx.getTxHash()} in ${timer.ms()}ms`, {
+        txHash: simulatedTx.getTxHash(),
         ...txInfo,
         ...(profileResult ? { gateCounts: profileResult.gateCounts } : {}),
         ...(publicOutput
@@ -798,20 +786,6 @@ export class PXEService implements PXE {
     }
   }
 
-  async #profileKernelProver(
-    txExecutionRequest: TxExecutionRequest,
-    proofCreator: PrivateKernelProver,
-    privateExecutionResult: PrivateExecutionResult,
-  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
-    const block = privateExecutionResult.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
-    const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node, block);
-    const kernelProver = new KernelProver(kernelOracle, proofCreator);
-
-    // Dry run the prover with profiler enabled
-    const result = await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult, true, true);
-    return result;
-  }
-
   /**
    * Generate a kernel proof, and create a private kernel output.
    * The function takes in a transaction execution request, and the result of private execution
@@ -826,13 +800,18 @@ export class PXEService implements PXE {
     txExecutionRequest: TxExecutionRequest,
     proofCreator: PrivateKernelProver,
     privateExecutionResult: PrivateExecutionResult,
+    { simulate, profile, dryRun }: ProvingConfig,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
     // use the block the tx was simulated against
     const block = privateExecutionResult.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
     const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node, block);
-    const kernelProver = new KernelProver(kernelOracle, proofCreator);
-    this.log.debug(`Executing kernel prover...`);
-    return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult);
+    const kernelProver = new KernelProver(kernelOracle, proofCreator, !this.proverEnabled);
+    this.log.debug(`Executing kernel prover (simulate: ${simulate}, profile: ${profile}, dryRun: ${dryRun})...`);
+    return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult, {
+      simulate,
+      profile,
+      dryRun,
+    });
   }
 
   public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {

package/src/simulator_oracle/index.ts

@@ -34,8 +34,8 @@ import { MessageLoadOracleInputs } from '@aztec/simulator/acvm';
 import { type AcirSimulator, type DBOracle } from '@aztec/simulator/client';
 
 import { type ContractDataOracle } from '../contract_data_oracle/index.js';
-import { type IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
+import { type NoteDao } from '../database/note_dao.js';
 import { produceNoteDaos } from '../note_decryption_utils/produce_note_daos.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
@@ -92,7 +92,7 @@ export class SimulatorOracle implements DBOracle {
   }
 
   async getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus, scopes?: AztecAddress[]) {
-    const noteDaos = await this.db.getIncomingNotes({
+    const noteDaos = await this.db.getNotes({
       contractAddress,
       storageSlot,
       status,
@@ -163,7 +163,7 @@ export class SimulatorOracle implements DBOracle {
    * @returns - The index of the commitment. Undefined if it does not exist in the tree.
    */
   async getCommitmentIndex(commitment: Fr) {
-    return await this.findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, commitment);
+    return await this.#findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, commitment);
   }
 
   // We need this in public as part of the EXISTS calls - but isn't used in private
@@ -172,19 +172,26 @@ export class SimulatorOracle implements DBOracle {
   }
 
   async getNullifierIndex(nullifier: Fr) {
-    return await this.findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
+    return await this.#findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
   }
 
-  public async findLeafIndex(
-    blockNumber: L2BlockNumber,
-    treeId: MerkleTreeId,
-    leafValue: Fr,
-  ): Promise<bigint | undefined> {
+  async #findLeafIndex(blockNumber: L2BlockNumber, treeId: MerkleTreeId, leafValue: Fr): Promise<bigint | undefined> {
     const [leafIndex] = await this.aztecNode.findLeavesIndexes(blockNumber, treeId, [leafValue]);
     return leafIndex;
   }
 
-  public async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: bigint): Promise<Fr[]> {
+  public async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+    const leafIndex = await this.#findLeafIndex(blockNumber, treeId, leafValue);
+    if (!leafIndex) {
+      throw new Error(`Leaf value: ${leafValue} not found in ${MerkleTreeId[treeId]}`);
+    }
+
+    const siblingPath = await this.#getSiblingPath(blockNumber, treeId, leafIndex);
+
+    return [new Fr(leafIndex), ...siblingPath];
+  }
+
+  async #getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: bigint): Promise<Fr[]> {
     switch (treeId) {
       case MerkleTreeId.NULLIFIER_TREE:
         return (await this.aztecNode.getNullifierSiblingPath(blockNumber, leafIndex)).toFields();
@@ -569,17 +576,17 @@ export class SimulatorOracle implements DBOracle {
     // Since we could have notes with the same index for different txs, we need
     // to keep track of them scoping by txHash
     const excludedIndices: Map<string, Set<number>> = new Map();
-    const incomingNotes: IncomingNoteDao[] = [];
+    const notes: NoteDao[] = [];
 
     const txEffectsCache = new Map<string, InBlock<TxEffect> | undefined>();
 
     for (const scopedLog of scopedLogs) {
-      const incomingNotePayload = scopedLog.isFromPublic
+      const notePayload = scopedLog.isFromPublic
         ? L1NotePayload.decryptAsIncomingFromPublic(scopedLog.logData, addressSecret)
         : L1NotePayload.decryptAsIncoming(PrivateLog.fromBuffer(scopedLog.logData), addressSecret);
 
-      if (incomingNotePayload) {
-        const payload = incomingNotePayload;
+      if (notePayload) {
+        const payload = notePayload;
 
         const txEffect =
           txEffectsCache.get(scopedLog.txHash.toString()) ?? (await this.aztecNode.getTxEffect(scopedLog.txHash));
@@ -594,15 +601,16 @@ export class SimulatorOracle implements DBOracle {
         if (!excludedIndices.has(scopedLog.txHash.toString())) {
           excludedIndices.set(scopedLog.txHash.toString(), new Set());
         }
-        const { incomingNote } = await produceNoteDaos(
+        const { note } = await produceNoteDaos(
           // I don't like this at all, but we need a simulator to run `computeNoteHashAndOptionallyANullifier`. This generates
           // a chicken-and-egg problem due to this oracle requiring a simulator, which in turn requires this oracle. Furthermore, since jest doesn't allow
           // mocking ESM exports, we have to pollute the method even more by providing a simulator parameter so tests can inject a fake one.
           simulator ?? getAcirSimulator(this.db, this.aztecNode, this.keyStore, this.contractDataOracle),
           this.db,
-          incomingNotePayload ? recipient.toAddressPoint() : undefined,
+          notePayload ? recipient.toAddressPoint() : undefined,
           payload!,
           txEffect.data.txHash,
+          txEffect.data.nullifiers[0],
           txEffect.l2BlockNumber,
           txEffect.l2BlockHash,
           txEffect.data.noteHashes,
@@ -611,12 +619,12 @@ export class SimulatorOracle implements DBOracle {
           this.log,
         );
 
-        if (incomingNote) {
-          incomingNotes.push(incomingNote);
+        if (note) {
+          notes.push(note);
         }
       }
     }
-    return { incomingNotes };
+    return { notes };
   }
 
   /**
@@ -629,10 +637,10 @@ export class SimulatorOracle implements DBOracle {
     recipient: AztecAddress,
     simulator?: AcirSimulator,
   ): Promise<void> {
-    const { incomingNotes } = await this.#decryptTaggedLogs(logs, recipient, simulator);
-    if (incomingNotes.length) {
-      await this.db.addNotes(incomingNotes, recipient);
-      incomingNotes.forEach(noteDao => {
+    const { notes } = await this.#decryptTaggedLogs(logs, recipient, simulator);
+    if (notes.length) {
+      await this.db.addNotes(notes, recipient);
+      notes.forEach(noteDao => {
         this.log.verbose(`Added incoming note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
           contract: noteDao.contractAddress,
           slot: noteDao.storageSlot,
@@ -644,7 +652,7 @@ export class SimulatorOracle implements DBOracle {
 
   public async removeNullifiedNotes(contractAddress: AztecAddress) {
     for (const recipient of await this.keyStore.getAccounts()) {
-      const currentNotesForRecipient = await this.db.getIncomingNotes({ contractAddress, owner: recipient });
+      const currentNotesForRecipient = await this.db.getNotes({ contractAddress, owner: recipient });
       const nullifiersToCheck = currentNotesForRecipient.map(note => note.siloedNullifier);
       const nullifierIndexes = await this.aztecNode.findNullifiersIndexesWithBlock('latest', nullifiersToCheck);
 
@@ -666,4 +674,26 @@ export class SimulatorOracle implements DBOracle {
       });
     }
   }
+
+  /**
+   * Used by contracts during execution to store arbitrary data in the local PXE database. The data is siloed/scoped
+   * to a specific `contract`.
+   * @param contract - An address of a contract that is requesting to store the data.
+   * @param key - A field element representing the key to store the data under.
+   * @param values - An array of field elements representing the data to store.
+   */
+  store(contract: AztecAddress, key: Fr, values: Fr[]): Promise<void> {
+    return this.db.store(contract, key, values);
+  }
+
+  /**
+   * Used by contracts during execution to load arbitrary data from the local PXE database. The data is siloed/scoped
+   * to a specific `contract`.
+   * @param contract - An address of a contract that is requesting to load the data.
+   * @param key - A field element representing the key under which to load the data..
+   * @returns An array of field elements representing the stored data or `null` if no data is stored under the key.
+   */
+  load(contract: AztecAddress, key: Fr): Promise<Fr[] | null> {
+    return this.db.load(contract, key);
+  }
 }

package/src/utils/create_pxe_service.ts

@@ -1,5 +1,5 @@
 import { BBNativePrivateKernelProver } from '@aztec/bb-prover';
-import { BBWasmPrivateKernelProver } from '@aztec/bb-prover/wasm';
+import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
 import { type AztecNode, type PrivateKernelProver } from '@aztec/circuit-types';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
@@ -9,7 +9,6 @@ import { L2TipsStore } from '@aztec/kv-store/stores';
 
 import { type PXEServiceConfig } from '../config/index.js';
 import { KVPxeDatabase } from '../database/kv_pxe_database.js';
-import { TestPrivateKernelProver } from '../kernel_prover/test/test_circuit_prover.js';
 import { PXEService } from '../pxe_service/pxe_service.js';
 
 /**
@@ -54,13 +53,8 @@ export async function createPXEService(
 }
 
 function createProver(config: PXEServiceConfig, logSuffix?: string) {
-  if (!config.proverEnabled) {
-    return new TestPrivateKernelProver();
-  }
-
-  // (@PhilWindle) Temporary validation until WASM is implemented
   if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return new BBWasmPrivateKernelProver(16);
+    return new BBWASMBundlePrivateKernelProver(16);
   } else {
     const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> &
       PXEServiceConfig;