@aztec/pxe 0.69.1 → 0.71.0

package/src/pxe_service/pxe_service.ts

@@ -65,7 +65,7 @@ import { type KeyStore } from '@aztec/key-store';
 import { type L2TipsStore } from '@aztec/kv-store/stores';
 import { ProtocolContractAddress, protocolContractNames } from '@aztec/protocol-contracts';
 import { getCanonicalProtocolContract } from '@aztec/protocol-contracts/bundle';
-import { type AcirSimulator } from '@aztec/simulator/client';
+import { type AcirSimulator, type SimulationProvider } from '@aztec/simulator/client';
 
 import { inspect } from 'util';
 
@@ -75,8 +75,7 @@ import { ContractDataOracle } from '../contract_data_oracle/index.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';
@@ -90,6 +89,7 @@ export class PXEService implements PXE {
   private simulator: AcirSimulator;
   private log: Logger;
   private packageVersion: string;
+  private proverEnabled: boolean;
 
   constructor(
     private keyStore: KeyStore,
@@ -97,14 +97,16 @@ export class PXEService implements PXE {
     private db: PxeDatabase,
     tipsStore: L2TipsStore,
     private proofCreator: PrivateKernelProver,
+    private simulationProvider: SimulationProvider,
     config: PXEServiceConfig,
     logSuffix?: string,
   ) {
     this.log = createLogger(logSuffix ? `pxe:service:${logSuffix}` : `pxe:service`);
     this.synchronizer = new Synchronizer(node, db, tipsStore, config, logSuffix);
     this.contractDataOracle = new ContractDataOracle(db);
-    this.simulator = getAcirSimulator(db, node, keyStore, this.contractDataOracle);
+    this.simulator = getAcirSimulator(db, node, keyStore, this.simulationProvider, this.contractDataOracle);
     this.packageVersion = getPackageInfo().version;
+    this.proverEnabled = !!config.proverEnabled;
   }
 
   /**
@@ -305,6 +307,10 @@ export class PXEService implements PXE {
     return await getNonNullifiedL1ToL2MessageWitness(this.node, contractAddress, messageHash, secret);
   }
 
+  public getL2ToL1MembershipWitness(blockNumber: number, l2Tol1Message: Fr): Promise<[bigint, SiblingPath<number>]> {
+    return this.node.getL2ToL1MessageMembershipWitness(blockNumber, l2Tol1Message);
+  }
+
   public async addNote(note: ExtendedNote, scope?: AztecAddress) {
     const owner = await this.db.getCompleteAddress(note.owner);
     if (!owner) {
@@ -453,20 +459,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));
@@ -501,17 +503,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();
@@ -526,8 +522,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
@@ -795,20 +791,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
@@ -823,13 +805,19 @@ 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 block =
+      privateExecutionResult.entrypoint.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/index.ts

@@ -1,6 +1,6 @@
 import { type AztecNode } from '@aztec/circuit-types';
 import { type KeyStore } from '@aztec/key-store';
-import { AcirSimulator } from '@aztec/simulator/client';
+import { AcirSimulator, type SimulationProvider } from '@aztec/simulator/client';
 
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
 import { type PxeDatabase } from '../database/pxe_database.js';
@@ -13,6 +13,7 @@ export function getAcirSimulator(
   db: PxeDatabase,
   aztecNode: AztecNode,
   keyStore: KeyStore,
+  simulationProvider: SimulationProvider,
   contractDataOracle?: ContractDataOracle,
 ) {
   const simulatorOracle = new SimulatorOracle(
@@ -20,6 +21,7 @@ export function getAcirSimulator(
     db,
     keyStore,
     aztecNode,
+    simulationProvider,
   );
-  return new AcirSimulator(simulatorOracle, aztecNode);
+  return new AcirSimulator(simulatorOracle, aztecNode, simulationProvider);
 }

package/src/simulator_oracle/index.ts

@@ -1,14 +1,16 @@
 import {
   type AztecNode,
+  type FunctionCall,
   type InBlock,
   L1NotePayload,
   type L2Block,
   type L2BlockNumber,
   MerkleTreeId,
+  Note,
   type NoteStatus,
   type NullifierMembershipWitness,
   type PublicDataWitness,
-  type TxEffect,
+  TxHash,
   type TxScopedL2Log,
   getNonNullifiedL1ToL2MessageWitness,
 } from '@aztec/circuit-types';
@@ -18,25 +20,38 @@ import {
   type CompleteAddress,
   type ContractInstance,
   Fr,
-  type FunctionSelector,
+  FunctionSelector,
   IndexedTaggingSecret,
   type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  MAX_NOTE_HASHES_PER_TX,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
   PrivateLog,
   computeAddressSecret,
   computeTaggingSecretPoint,
 } from '@aztec/circuits.js';
-import { type FunctionArtifact, getFunctionArtifact } from '@aztec/foundation/abi';
+import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
+import {
+  type FunctionArtifact,
+  FunctionType,
+  NoteSelector,
+  encodeArguments,
+  getFunctionArtifact,
+} from '@aztec/foundation/abi';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { type KeyStore } from '@aztec/key-store';
-import { MessageLoadOracleInputs } from '@aztec/simulator/acvm';
-import { type AcirSimulator, type DBOracle } from '@aztec/simulator/client';
+import {
+  type AcirSimulator,
+  type DBOracle,
+  MessageLoadOracleInputs,
+  type SimulationProvider,
+} from '@aztec/simulator/client';
 
-import { type ContractDataOracle } from '../contract_data_oracle/index.js';
+import { ContractDataOracle } from '../contract_data_oracle/index.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 { NoteDao } from '../database/note_dao.js';
+import { getOrderedNoteItems } from '../note_decryption_utils/add_public_values_to_payload.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 
@@ -49,6 +64,7 @@ export class SimulatorOracle implements DBOracle {
     private db: PxeDatabase,
     private keyStore: KeyStore,
     private aztecNode: AztecNode,
+    private simulationProvider: SimulationProvider,
     private log = createLogger('pxe:simulator_oracle'),
   ) {}
 
@@ -163,7 +179,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 +188,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();
@@ -419,6 +442,8 @@ export class SimulatorOracle implements DBOracle {
     maxBlockNumber: number,
     scopes?: AztecAddress[],
   ): Promise<Map<string, TxScopedL2Log[]>> {
+    this.log.verbose('Searching for tagged logs', { contract: contractAddress });
+
     // Ideally this algorithm would be implemented in noir, exposing its building blocks as oracles.
     // However it is impossible at the moment due to the language not supporting nested slices.
     // This nesting is necessary because for a given set of tags we don't
@@ -556,10 +581,9 @@ export class SimulatorOracle implements DBOracle {
    * Decrypts logs tagged for a recipient and returns them.
    * @param scopedLogs - The logs to decrypt.
    * @param recipient - The recipient of the logs.
-   * @param simulator - The simulator to use for decryption.
    * @returns The decrypted notes.
    */
-  async #decryptTaggedLogs(scopedLogs: TxScopedL2Log[], recipient: AztecAddress, simulator?: AcirSimulator) {
+  async #decryptTaggedLogs(scopedLogs: TxScopedL2Log[], recipient: AztecAddress) {
     const recipientCompleteAddress = await this.getCompleteAddress(recipient);
     const ivskM = await this.keyStore.getMasterSecretKey(
       recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey,
@@ -569,54 +593,29 @@ 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 notes: NoteDao[] = [];
-
-    const txEffectsCache = new Map<string, InBlock<TxEffect> | undefined>();
+    const decrypted = [];
 
     for (const scopedLog of scopedLogs) {
-      const notePayload = scopedLog.isFromPublic
+      const payload = scopedLog.isFromPublic
         ? L1NotePayload.decryptAsIncomingFromPublic(scopedLog.logData, addressSecret)
         : L1NotePayload.decryptAsIncoming(PrivateLog.fromBuffer(scopedLog.logData), addressSecret);
 
-      if (notePayload) {
-        const payload = notePayload;
-
-        const txEffect =
-          txEffectsCache.get(scopedLog.txHash.toString()) ?? (await this.aztecNode.getTxEffect(scopedLog.txHash));
-
-        if (!txEffect) {
-          this.log.warn(`No tx effect found for ${scopedLog.txHash} while decrypting tagged logs`);
-          continue;
-        }
+      if (!payload) {
+        this.log.verbose('Unable to decrypt log');
+        continue;
+      }
 
-        txEffectsCache.set(scopedLog.txHash.toString(), txEffect);
+      if (!excludedIndices.has(scopedLog.txHash.toString())) {
+        excludedIndices.set(scopedLog.txHash.toString(), new Set());
+      }
 
-        if (!excludedIndices.has(scopedLog.txHash.toString())) {
-          excludedIndices.set(scopedLog.txHash.toString(), new Set());
-        }
-        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,
-          notePayload ? recipient.toAddressPoint() : undefined,
-          payload!,
-          txEffect.data.txHash,
-          txEffect.l2BlockNumber,
-          txEffect.l2BlockHash,
-          txEffect.data.noteHashes,
-          scopedLog.dataStartIndexForTx,
-          excludedIndices.get(scopedLog.txHash.toString())!,
-          this.log,
-        );
+      const note = await getOrderedNoteItems(this.db, payload);
+      const plaintext = [payload.storageSlot, payload.noteTypeId.toField(), ...note.items];
 
-        if (note) {
-          notes.push(note);
-        }
-      }
+      decrypted.push({ plaintext, txHash: scopedLog.txHash, contractAddress: payload.contractAddress });
     }
-    return { notes };
+
+    return decrypted;
   }
 
   /**
@@ -629,20 +628,68 @@ export class SimulatorOracle implements DBOracle {
     recipient: AztecAddress,
     simulator?: AcirSimulator,
   ): Promise<void> {
-    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,
-          nullifier: noteDao.siloedNullifier.toString(),
-        });
-      });
+    const decryptedLogs = await this.#decryptTaggedLogs(logs, recipient);
+
+    // We've produced the full NoteDao, which we'd be able to simply insert into the database. However, this is
+    // only a temporary measure as we migrate from the PXE-driven discovery into the new contract-driven approach. We
+    // discard most of the work done up to this point and reconstruct the note plaintext to then hand over to the
+    // contract for further processing.
+    for (const decryptedLog of decryptedLogs) {
+      // Log processing requires the note hashes in the tx in which the note was created. We are now assuming that the
+      // note was included in the same block in which the log was delivered - note that partial notes will not work this
+      // way.
+      const txEffect = await this.aztecNode.getTxEffect(decryptedLog.txHash);
+      if (!txEffect) {
+        throw new Error(`Could not find tx effect for tx hash ${decryptedLog.txHash}`);
+      }
+
+      // This will trigger calls to the deliverNote oracle
+      await this.callProcessLog(
+        decryptedLog.contractAddress,
+        decryptedLog.plaintext,
+        decryptedLog.txHash,
+        txEffect.data.noteHashes,
+        txEffect.data.nullifiers[0],
+        recipient,
+        simulator,
+      );
     }
+    return;
+  }
+
+  // Called when notes are delivered, usually as a result to a call to the process_log contract function
+  public async deliverNote(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    nonce: Fr,
+    content: Fr[],
+    noteHash: Fr,
+    nullifier: Fr,
+    txHash: Fr,
+    recipient: AztecAddress,
+  ): Promise<void> {
+    const noteDao = await this.produceNoteDao(
+      contractAddress,
+      storageSlot,
+      nonce,
+      content,
+      noteHash,
+      nullifier,
+      txHash,
+      recipient,
+    );
+
+    await this.db.addNotes([noteDao], recipient);
+    this.log.verbose('Added note', {
+      contract: noteDao.contractAddress,
+      slot: noteDao.storageSlot,
+      nullifier: noteDao.siloedNullifier.toString,
+    });
   }
 
   public async removeNullifiedNotes(contractAddress: AztecAddress) {
+    this.log.verbose('Removing nullified notes', { contract: contractAddress });
+
     for (const recipient of await this.keyStore.getAccounts()) {
       const currentNotesForRecipient = await this.db.getNotes({ contractAddress, owner: recipient });
       const nullifiersToCheck = currentNotesForRecipient.map(note => note.siloedNullifier);
@@ -666,4 +713,114 @@ export class SimulatorOracle implements DBOracle {
       });
     }
   }
+
+  async produceNoteDao(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    nonce: Fr,
+    content: Fr[],
+    noteHash: Fr,
+    nullifier: Fr,
+    txHash: Fr,
+    recipient: AztecAddress,
+  ): Promise<NoteDao> {
+    const receipt = await this.aztecNode.getTxReceipt(new TxHash(txHash));
+    if (receipt === undefined) {
+      throw new Error(`Failed to fetch tx receipt for tx hash ${txHash} when searching for note hashes`);
+    }
+    const { blockNumber, blockHash } = receipt;
+
+    const uniqueNoteHash = computeUniqueNoteHash(nonce, siloNoteHash(contractAddress, noteHash));
+    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+
+    const uniqueNoteHashTreeIndex = (
+      await this.aztecNode.findLeavesIndexes(blockNumber!, MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash])
+    )[0];
+    if (uniqueNoteHashTreeIndex === undefined) {
+      throw new Error(
+        `Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${blockNumber} (from tx ${txHash})`,
+      );
+    }
+
+    return new NoteDao(
+      new Note(content),
+      contractAddress,
+      storageSlot,
+      nonce,
+      noteHash,
+      siloedNullifier,
+      new TxHash(txHash),
+      blockNumber!,
+      blockHash!.toString(),
+      uniqueNoteHashTreeIndex,
+      recipient.toAddressPoint(),
+      NoteSelector.empty(), // todo: remove
+    );
+  }
+
+  async callProcessLog(
+    contractAddress: AztecAddress,
+    logPlaintext: Fr[],
+    txHash: TxHash,
+    noteHashes: Fr[],
+    firstNullifier: Fr,
+    recipient: AztecAddress,
+    simulator?: AcirSimulator,
+  ) {
+    const artifact: FunctionArtifact | undefined = await new ContractDataOracle(this.db).getFunctionArtifactByName(
+      contractAddress,
+      'process_log',
+    );
+    if (!artifact) {
+      throw new Error(
+        `Mandatory implementation of "process_log" missing in noir contract ${contractAddress.toString()}.`,
+      );
+    }
+
+    const execRequest: FunctionCall = {
+      name: artifact.name,
+      to: contractAddress,
+      selector: FunctionSelector.fromNameAndParameters(artifact),
+      type: FunctionType.UNCONSTRAINED,
+      isStatic: artifact.isStatic,
+      args: encodeArguments(artifact, [
+        toBoundedVec(logPlaintext, PRIVATE_LOG_SIZE_IN_FIELDS),
+        txHash.toString(),
+        toBoundedVec(noteHashes, MAX_NOTE_HASHES_PER_TX),
+        firstNullifier,
+        recipient,
+      ]),
+      returnTypes: artifact.returnTypes,
+    };
+
+    await (
+      simulator ??
+      getAcirSimulator(this.db, this.aztecNode, this.keyStore, this.simulationProvider, this.contractDataOracle)
+    ).runUnconstrained(
+      execRequest,
+      artifact,
+      contractAddress,
+      [], // empty scope as this call should not require access to private information
+    );
+  }
+
+  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void> {
+    return this.db.dbStore(contractAddress, slot, values);
+  }
+
+  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    return this.db.dbLoad(contractAddress, slot);
+  }
+
+  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    return this.db.dbDelete(contractAddress, slot);
+  }
+
+  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+    return this.db.dbCopy(contractAddress, srcSlot, dstSlot, numEntries);
+  }
+}
+
+function toBoundedVec(array: Fr[], maxLength: number) {
+  return { storage: array.concat(Array(maxLength - array.length).fill(new Fr(0))), len: array.length };
 }

package/src/utils/create_pxe_service.ts

@@ -1,15 +1,15 @@
 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';
 import { KeyStore } from '@aztec/key-store';
 import { createStore } from '@aztec/kv-store/lmdb';
 import { L2TipsStore } from '@aztec/kv-store/stores';
+import { type SimulationProvider, WASMSimulator } from '@aztec/simulator/client';
 
 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';
 
 /**
@@ -46,25 +46,20 @@ export async function createPXEService(
 
   const db = await KVPxeDatabase.create(store);
   const tips = new L2TipsStore(store, 'pxe');
-
-  const prover = proofCreator ?? (await createProver(config, logSuffix));
-  const pxe = new PXEService(keyStore, aztecNode, db, tips, prover, config, logSuffix);
+  const simulationProvider = new WASMSimulator();
+  const prover = proofCreator ?? (await createProver(config, simulationProvider, logSuffix));
+  const pxe = new PXEService(keyStore, aztecNode, db, tips, prover, simulationProvider, config, logSuffix);
   await pxe.init();
   return pxe;
 }
 
-function createProver(config: PXEServiceConfig, logSuffix?: string) {
-  if (!config.proverEnabled) {
-    return new TestPrivateKernelProver();
-  }
-
-  // (@PhilWindle) Temporary validation until WASM is implemented
+function createProver(config: PXEServiceConfig, simulationProvider: SimulationProvider, logSuffix?: string) {
   if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return new BBWasmPrivateKernelProver(16);
+    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 }, log);
+    return BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulationProvider, log);
   }
 }

package/dest/kernel_prover/test/test_circuit_prover.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
-import { ClientIvcProof, type PrivateKernelCircuitPublicInputs, type PrivateKernelInitCircuitPrivateInputs, type PrivateKernelInnerCircuitPrivateInputs, type PrivateKernelResetCircuitPrivateInputs, type PrivateKernelTailCircuitPrivateInputs, type PrivateKernelTailCircuitPublicInputs } from '@aztec/circuits.js';
-import { type WitnessMap } from '@noir-lang/types';
-/**
- * Test Proof Creator executes circuit simulations and provides fake proofs.
- */
-export declare class TestPrivateKernelProver implements PrivateKernelProver {
-    private log;
-    constructor(log?: import("@aztec/foundation/log").Logger);
-    createClientIvcProof(_acirs: Buffer[], _witnessStack: WitnessMap[]): Promise<ClientIvcProof>;
-    simulateProofInit(privateInputs: PrivateKernelInitCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    simulateProofInner(privateInputs: PrivateKernelInnerCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    simulateProofReset(privateInputs: PrivateKernelResetCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    simulateProofTail(privateInputs: PrivateKernelTailCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
-    computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number>;
-    private makeEmptyKernelSimulateOutput;
-}
-//# sourceMappingURL=test_circuit_prover.d.ts.map

package/dest/kernel_prover/test/test_circuit_prover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test_circuit_prover.d.ts","sourceRoot":"","sources":["../../../src/kernel_prover/test/test_circuit_prover.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAElG,OAAO,EACL,cAAc,EACd,KAAK,gCAAgC,EACrC,KAAK,qCAAqC,EAC1C,KAAK,sCAAsC,EAC3C,KAAK,sCAAsC,EAC3C,KAAK,qCAAqC,EAC1C,KAAK,oCAAoC,EAC1C,MAAM,oBAAoB,CAAC;AAe5B,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;GAEG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IACrD,OAAO,CAAC,GAAG;gBAAH,GAAG,yCAAyC;IAEhE,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAI/E,iBAAiB,CAC5B,aAAa,EAAE,qCAAqC,GACnD,OAAO,CAAC,2BAA2B,CAAC,gCAAgC,CAAC,CAAC;IAY5D,kBAAkB,CAC7B,aAAa,EAAE,sCAAsC,GACpD,OAAO,CAAC,2BAA2B,CAAC,gCAAgC,CAAC,CAAC;IAY5D,kBAAkB,CAC7B,aAAa,EAAE,sCAAsC,GACpD,OAAO,CAAC,2BAA2B,CAAC,gCAAgC,CAAC,CAAC;IAkB5D,iBAAiB,CAC5B,aAAa,EAAE,qCAAqC,GACnD,OAAO,CAAC,2BAA2B,CAAC,oCAAoC,CAAC,CAAC;IAkBtE,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK3F,OAAO,CAAC,6BAA6B;CAWtC"}