@aztec/pxe 0.0.1-commit.24de95ac → 0.0.1-commit.3469e52

package/src/contract_function_simulator/oracle/utility_execution_oracle.ts

@@ -1,19 +1,43 @@
-import { Aes128 } from '@aztec/foundation/crypto';
-import { Fr, Point } from '@aztec/foundation/fields';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { Aes128 } from '@aztec/foundation/crypto/aes128';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import type { KeyStore } from '@aztec/key-store';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import { siloNullifier } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import { computeAddressSecret } from '@aztec/stdlib/keys';
+import { deriveEcdhSharedSecret } from '@aztec/stdlib/logs';
 import type { NoteStatus } from '@aztec/stdlib/note';
-import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import { MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader, Capsule } from '@aztec/stdlib/tx';
 
-import type { ExecutionDataProvider } from '../execution_data_provider.js';
+import { EventService } from '../../events/event_service.js';
+import { LogService } from '../../logs/log_service.js';
+import { NoteService } from '../../notes/note_service.js';
+import { ORACLE_VERSION } from '../../oracle_version.js';
+import type { AddressStore } from '../../storage/address_store/address_store.js';
+import type { AnchorBlockStore } from '../../storage/anchor_block_store/anchor_block_store.js';
+import type { CapsuleStore } from '../../storage/capsule_store/capsule_store.js';
+import type { ContractStore } from '../../storage/contract_store/contract_store.js';
+import type { NoteStore } from '../../storage/note_store/note_store.js';
+import type { PrivateEventStore } from '../../storage/private_event_store/private_event_store.js';
+import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
+import type { SenderAddressBookStore } from '../../storage/tagging_store/sender_address_book_store.js';
+import { TreeMembershipService } from '../../tree_membership/tree_membership_service.js';
+import { EventValidationRequest } from '../noir-structs/event_validation_request.js';
+import { LogRetrievalRequest } from '../noir-structs/log_retrieval_request.js';
+import { LogRetrievalResponse } from '../noir-structs/log_retrieval_response.js';
+import { NoteValidationRequest } from '../noir-structs/note_validation_request.js';
 import { UtilityContext } from '../noir-structs/utility_context.js';
 import { pickNotes } from '../pick_notes.js';
 import type { IMiscOracle, IUtilityExecutionOracle, NoteData } from './interfaces.js';
+import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
 
 /**
  * The oracle for an execution of utility contract functions.
@@ -29,28 +53,34 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     /** List of transient auth witnesses to be used during this simulation */
     protected readonly authWitnesses: AuthWitness[],
     protected readonly capsules: Capsule[], // TODO(#12425): Rename to transientCapsules
-    protected readonly executionDataProvider: ExecutionDataProvider,
+    protected readonly anchorBlockHeader: BlockHeader,
+    protected readonly contractStore: ContractStore,
+    protected readonly noteStore: NoteStore,
+    protected readonly keyStore: KeyStore,
+    protected readonly addressStore: AddressStore,
+    protected readonly aztecNode: AztecNode,
+    protected readonly anchorBlockStore: AnchorBlockStore,
+    protected readonly recipientTaggingStore: RecipientTaggingStore,
+    protected readonly senderAddressBookStore: SenderAddressBookStore,
+    protected readonly capsuleStore: CapsuleStore,
+    protected readonly privateEventStore: PrivateEventStore,
+    protected readonly jobId: string,
     protected log = createLogger('simulator:client_view_context'),
     protected readonly scopes?: AztecAddress[],
   ) {}
 
   public utilityAssertCompatibleOracleVersion(version: number): void {
-    this.executionDataProvider.assertCompatibleOracleVersion(version);
+    if (version !== ORACLE_VERSION) {
+      throw new Error(`Incompatible oracle version. Expected version ${ORACLE_VERSION}, got ${version}.`);
+    }
   }
 
   public utilityGetRandomField(): Fr {
     return Fr.random();
   }
 
-  public async utilityGetUtilityContext(): Promise<UtilityContext> {
-    const blockHeader = await this.executionDataProvider.getAnchorBlockHeader();
-    return UtilityContext.from({
-      blockNumber: blockHeader.globalVariables.blockNumber,
-      timestamp: blockHeader.globalVariables.timestamp,
-      contractAddress: this.contractAddress,
-      version: blockHeader.globalVariables.version,
-      chainId: blockHeader.globalVariables.chainId,
-    });
+  public utilityGetUtilityContext(): UtilityContext {
+    return new UtilityContext(this.anchorBlockHeader, this.contractAddress);
   }
 
   /**
@@ -60,36 +90,37 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @throws If the keys are not registered in the key store.
    */
   public utilityGetKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest> {
-    return this.executionDataProvider.getKeyValidationRequest(pkMHash, this.contractAddress);
+    return this.keyStore.getKeyValidationRequest(pkMHash, this.contractAddress);
   }
 
   /**
    * Fetches the index and sibling path of a leaf at a given block from a given tree.
-   * @param blockNumber - The block number at which to get the membership witness.
+   * @param blockHash - The block hash at which to get the membership witness.
    * @param treeId - Id of the tree to get the sibling path from.
    * @param leafValue - The leaf value
    * @returns The index and sibling path concatenated [index, sibling_path]
    */
-  public utilityGetMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
-    return this.executionDataProvider.getMembershipWitness(blockNumber, treeId, leafValue);
+  public utilityGetMembershipWitness(blockHash: L2BlockHash, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+    const treeMembershipService = new TreeMembershipService(this.aztecNode);
+    return treeMembershipService.getMembershipWitness(blockHash, treeId, leafValue);
   }
 
   /**
    * Returns a nullifier membership witness for a given nullifier at a given block.
-   * @param blockNumber - The block number at which to get the index.
+   * @param blockHash - The block hash at which to get the index.
    * @param nullifier - Nullifier we try to find witness for.
    * @returns The nullifier membership witness (if found).
    */
   public async utilityGetNullifierMembershipWitness(
-    blockNumber: number,
+    blockHash: L2BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    return await this.executionDataProvider.getNullifierMembershipWitness(blockNumber, nullifier);
+    return await this.aztecNode.getNullifierMembershipWitness(blockHash, nullifier);
   }
 
   /**
    * Returns a low nullifier membership witness for a given nullifier at a given block.
-   * @param blockNumber - The block number at which to get the index.
+   * @param blockHash - The block hash at which to get the index.
    * @param nullifier - Nullifier we try to find the low nullifier witness for.
    * @returns The low nullifier membership witness (if found).
    * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
@@ -97,20 +128,25 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * we are trying to prove non-inclusion for.
    */
   public async utilityGetLowNullifierMembershipWitness(
-    blockNumber: number,
+    blockHash: L2BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    return await this.executionDataProvider.getLowNullifierMembershipWitness(blockNumber, nullifier);
+    const treeMembershipService = new TreeMembershipService(this.aztecNode);
+    return await treeMembershipService.getLowNullifierMembershipWitness(blockHash, nullifier);
   }
 
   /**
    * Returns a public data tree witness for a given leaf slot at a given block.
-   * @param blockNumber - The block number at which to get the index.
+   * @param blockHash - The block hash at which to get the index.
    * @param leafSlot - The slot of the public data tree to get the witness for.
    * @returns - The witness
    */
-  public async utilityGetPublicDataWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    return await this.executionDataProvider.getPublicDataWitness(blockNumber, leafSlot);
+  public async utilityGetPublicDataWitness(
+    blockHash: L2BlockHash,
+    leafSlot: Fr,
+  ): Promise<PublicDataWitness | undefined> {
+    const treeMembershipService = new TreeMembershipService(this.aztecNode);
+    return await treeMembershipService.getPublicDataWitness(blockHash, leafSlot);
   }
 
   /**
@@ -118,12 +154,14 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @param blockNumber - The number of a block of which to get the block header.
    * @returns Block extracted from a block with block number `blockNumber`.
    */
-  public async utilityGetBlockHeader(blockNumber: number): Promise<BlockHeader | undefined> {
-    const block = await this.executionDataProvider.getBlock(blockNumber);
-    if (!block) {
-      return undefined;
+  public async utilityGetBlockHeader(blockNumber: BlockNumber): Promise<BlockHeader | undefined> {
+    const anchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
+    if (blockNumber > anchorBlockNumber) {
+      throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
     }
-    return block.getBlockHeader();
+
+    const block = await this.aztecNode.getBlock(blockNumber);
+    return block?.header;
   }
 
   /**
@@ -133,7 +171,18 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @throws An error if the account is not registered in the database.
    */
   public utilityGetPublicKeysAndPartialAddress(account: AztecAddress): Promise<CompleteAddress> {
-    return this.executionDataProvider.getCompleteAddress(account);
+    return this.getCompleteAddress(account);
+  }
+
+  protected async getCompleteAddress(account: AztecAddress): Promise<CompleteAddress> {
+    const completeAddress = await this.addressStore.getCompleteAddress(account);
+    if (!completeAddress) {
+      throw new Error(
+        `No public key registered for address ${account}.
+        Register it by calling pxe.addAccount(...).\nSee docs for context: https://docs.aztec.network/developers/resources/debugging/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`,
+      );
+    }
+    return completeAddress;
   }
 
   /**
@@ -142,7 +191,15 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @returns A contract instance.
    */
   public utilityGetContractInstance(address: AztecAddress): Promise<ContractInstance> {
-    return this.executionDataProvider.getContractInstance(address);
+    return this.getContractInstance(address);
+  }
+
+  protected async getContractInstance(address: AztecAddress): Promise<ContractInstance> {
+    const instance = await this.contractStore.getContractInstance(address);
+    if (!instance) {
+      throw new Error(`No contract instance found for address ${address.toString()}`);
+    }
+    return instance;
   }
 
   /**
@@ -164,6 +221,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * Real notes coming from DB will have a leafIndex which
    * represents their index in the note hash tree.
    *
+   * @param owner - The owner of the notes. If undefined, returns notes for all owners.
    * @param storageSlot - The storage slot.
    * @param numSelects - The number of valid selects in selectBy and selectValues.
    * @param selectBy - An array of indices of the fields to selects.
@@ -177,6 +235,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @returns Array of note data.
    */
   public async utilityGetNotes(
+    owner: AztecAddress | undefined,
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -192,7 +251,9 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     offset: number,
     status: NoteStatus,
   ): Promise<NoteData[]> {
-    const dbNotes = await this.executionDataProvider.getNotes(this.contractAddress, storageSlot, status, this.scopes);
+    const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockStore);
+
+    const dbNotes = await noteService.getNotes(this.contractAddress, owner, storageSlot, status, this.scopes);
     return pickNotes<NoteData>(dbNotes, {
       selects: selectByIndexes.slice(0, numSelects).map((index, i) => ({
         selector: { index, offset: selectByOffsets[i], length: selectByLengths[i] },
@@ -215,12 +276,13 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    */
   public async utilityCheckNullifierExists(innerNullifier: Fr) {
     const nullifier = await siloNullifier(this.contractAddress, innerNullifier!);
-    const index = await this.executionDataProvider.getNullifierIndex(nullifier);
+    const treeMembershipService = new TreeMembershipService(this.aztecNode);
+    const index = await treeMembershipService.getNullifierIndex(nullifier);
     return index !== undefined;
   }
 
   /**
-   * Fetches a message from the executionDataProvider, given its key.
+   * Fetches a message from the executionStore, given its key.
    * @param contractAddress - Address of a contract by which the message was emitted.
    * @param messageHash - Hash of the message.
    * @param secret - Secret used to compute a nullifier.
@@ -228,26 +290,37 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
    */
   public async utilityGetL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
-    return await this.executionDataProvider.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
+    const treeMembershipService = new TreeMembershipService(this.aztecNode);
+    const [messageIndex, siblingPath] = await treeMembershipService.getL1ToL2MembershipWitness(
+      contractAddress,
+      messageHash,
+      secret,
+    );
+
+    // Assuming messageIndex is what you intended to use for the index in MessageLoadOracleInputs
+    return new MessageLoadOracleInputs(messageIndex, siblingPath);
   }
 
   /**
    * Read the public storage data.
+   * @param blockHash - The block hash to read storage at.
    * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
-   * @param blockNumber - The block number to read storage at.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
   public async utilityStorageRead(
+    blockHash: L2BlockHash,
     contractAddress: AztecAddress,
     startStorageSlot: Fr,
-    blockNumber: number,
     numberOfElements: number,
   ) {
     const values = [];
+
+    // TODO: why do we serialize these requests? This should probably a single call
+    // Privacy considerations?
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
-      const value = await this.executionDataProvider.getPublicStorageAt(blockNumber, contractAddress, storageSlot);
+      const value = await this.aztecNode.getPublicStorageAt(blockHash, contractAddress, storageSlot);
 
       this.log.debug(
         `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
@@ -266,26 +339,93 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
   }
 
   public async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
-    await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
+    const logService = new LogService(
+      this.aztecNode,
+      this.anchorBlockStore,
+      this.keyStore,
+      this.capsuleStore,
+      this.recipientTaggingStore,
+      this.senderAddressBookStore,
+      this.addressStore,
+      this.jobId,
+    );
+
+    const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockStore);
 
-    await this.executionDataProvider.syncNoteNullifiers(this.contractAddress);
+    // It is acceptable to run the following operations in parallel for several reasons:
+    // 1. syncTaggedLogs does not write to the note store — it only stores the pending tagged logs in a capsule array,
+    //    which is then processed in Noir after this handler returns.
+    // 2. Even if syncTaggedLogs did write to the note store, it would not cause inconsistent state.
+    await Promise.all([
+      logService.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes),
+      noteService.syncNoteNullifiers(this.contractAddress),
+    ]);
   }
 
+  /**
+   * Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and
+   * `enqueue_event_for_validation`, inserting them into the note database and event store respectively, making them
+   * queryable via `get_notes` and `getPrivateEvents`.
+   *
+   * This automatically clears both validation request queues, so no further work needs to be done by the caller.
+   * @param contractAddress - The address of the contract that the logs are tagged for.
+   * @param noteValidationRequestsArrayBaseSlot - The base slot of capsule array containing note validation requests.
+   * @param eventValidationRequestsArrayBaseSlot - The base slot of capsule array containing event validation requests.
+   */
   public async utilityValidateEnqueuedNotesAndEvents(
     contractAddress: AztecAddress,
     noteValidationRequestsArrayBaseSlot: Fr,
     eventValidationRequestsArrayBaseSlot: Fr,
   ) {
-    // TODO(#10727): allow other contracts to deliver notes
+    // TODO(#10727): allow other contracts to store notes
     if (!this.contractAddress.equals(contractAddress)) {
       throw new Error(`Got a note validation request from ${contractAddress}, expected ${this.contractAddress}`);
     }
 
-    await this.executionDataProvider.validateEnqueuedNotesAndEvents(
-      contractAddress,
-      noteValidationRequestsArrayBaseSlot,
-      eventValidationRequestsArrayBaseSlot,
+    // We read all note and event validation requests and process them all concurrently. This makes the process much
+    // faster as we don't need to wait for the network round-trip.
+    const noteValidationRequests = (
+      await this.capsuleStore.readCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, this.jobId)
+    ).map(NoteValidationRequest.fromFields);
+
+    const eventValidationRequests = (
+      await this.capsuleStore.readCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, this.jobId)
+    ).map(EventValidationRequest.fromFields);
+
+    const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockStore);
+    const noteStorePromises = noteValidationRequests.map(request =>
+      noteService.storeNote(
+        request.contractAddress,
+        request.owner,
+        request.storageSlot,
+        request.randomness,
+        request.noteNonce,
+        request.content,
+        request.noteHash,
+        request.nullifier,
+        request.txHash,
+        request.recipient,
+      ),
     );
+
+    const eventService = new EventService(this.anchorBlockStore, this.aztecNode, this.privateEventStore, this.jobId);
+    const eventStorePromises = eventValidationRequests.map(request =>
+      eventService.storeEvent(
+        request.contractAddress,
+        request.eventTypeId,
+        request.randomness,
+        request.serializedEvent,
+        request.eventCommitment,
+        request.txHash,
+        request.recipient,
+      ),
+    );
+
+    await Promise.all([...noteStorePromises, ...eventStorePromises]);
+
+    // Requests are cleared once we're done.
+    await this.capsuleStore.setCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, [], this.jobId);
+    await this.capsuleStore.setCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, [], this.jobId);
   }
 
   public async utilityBulkRetrieveLogs(
@@ -298,10 +438,34 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
       throw new Error(`Got a note validation request from ${contractAddress}, expected ${this.contractAddress}`);
     }
 
-    await this.executionDataProvider.bulkRetrieveLogs(
+    // We read all log retrieval requests and process them all concurrently. This makes the process much faster as we
+    // don't need to wait for the network round-trip.
+    const logRetrievalRequests = (
+      await this.capsuleStore.readCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot, this.jobId)
+    ).map(LogRetrievalRequest.fromFields);
+
+    const logService = new LogService(
+      this.aztecNode,
+      this.anchorBlockStore,
+      this.keyStore,
+      this.capsuleStore,
+      this.recipientTaggingStore,
+      this.senderAddressBookStore,
+      this.addressStore,
+      this.jobId,
+    );
+
+    const maybeLogRetrievalResponses = await logService.bulkRetrieveLogs(logRetrievalRequests);
+
+    // Requests are cleared once we're done.
+    await this.capsuleStore.setCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot, [], this.jobId);
+
+    // The responses are stored as Option<LogRetrievalResponse> in a second CapsuleArray.
+    await this.capsuleStore.setCapsuleArray(
       contractAddress,
-      logRetrievalRequestsArrayBaseSlot,
       logRetrievalResponsesArrayBaseSlot,
+      maybeLogRetrievalResponses.map(LogRetrievalResponse.toSerializedOption),
+      this.jobId,
     );
   }
 
@@ -310,7 +474,8 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
       // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
       throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
     }
-    return this.executionDataProvider.storeCapsule(this.contractAddress, slot, capsule);
+    this.capsuleStore.storeCapsule(this.contractAddress, slot, capsule, this.jobId);
+    return Promise.resolve();
   }
 
   public async utilityLoadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
@@ -321,7 +486,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     return (
       // TODO(#12425): On the following line, the pertinent capsule gets overshadowed by the transient one. Tackle this.
       this.capsules.find(c => c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ??
-      (await this.executionDataProvider.loadCapsule(this.contractAddress, slot))
+      (await this.capsuleStore.loadCapsule(this.contractAddress, slot, this.jobId))
     );
   }
 
@@ -330,7 +495,8 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
       // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
       throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
     }
-    return this.executionDataProvider.deleteCapsule(this.contractAddress, slot);
+    this.capsuleStore.deleteCapsule(this.contractAddress, slot, this.jobId);
+    return Promise.resolve();
   }
 
   public utilityCopyCapsule(
@@ -343,7 +509,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
       // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
       throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
     }
-    return this.executionDataProvider.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
+    return this.capsuleStore.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries, this.jobId);
   }
 
   // TODO(#11849): consider replacing this oracle with a pure Noir implementation of aes decryption.
@@ -352,7 +518,23 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     return aes128.decryptBufferCBC(ciphertext, iv, symKey);
   }
 
+  /**
+   * Retrieves the shared secret for a given address and ephemeral public key.
+   * @param address - The address to get the secret for.
+   * @param ephPk - The ephemeral public key to get the secret for.
+   * @returns The secret for the given address.
+   */
   public utilityGetSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
-    return this.executionDataProvider.getSharedSecret(address, ephPk);
+    return this.getSharedSecret(address, ephPk);
+  }
+
+  protected async getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
+    // TODO(#12656): return an app-siloed secret
+    const recipientCompleteAddress = await this.getCompleteAddress(address);
+    const ivskM = await this.keyStore.getMasterSecretKey(
+      recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey,
+    );
+    const addressSecret = await computeAddressSecret(await recipientCompleteAddress.getPreaddress(), ivskM);
+    return deriveEcdhSharedSecret(addressSecret, ephPk);
   }
 }

package/src/contract_function_simulator/pick_notes.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { Comparator, type Note } from '@aztec/stdlib/note';
 
 export interface PropertySelector {

package/src/contract_function_simulator/proxied_contract_data_source.ts

@@ -2,21 +2,21 @@ import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractOverrides } from '@aztec/stdlib/tx';
 
-import type { ContractDataProvider } from '../storage/index.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
 
 /*
- * Proxy generator for a ContractDataProvider that allows overriding contract instances and artifacts, so
+ * 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 ProxiedContractDataProviderFactory {
-  static create(contractDataProvider: ContractDataProvider, overrides?: ContractOverrides) {
+export class ProxiedContractStoreFactory {
+  static create(contractStore: ContractStore, overrides?: ContractOverrides) {
     if (!overrides) {
-      return contractDataProvider;
+      return contractStore;
     }
 
-    return new Proxy(contractDataProvider, {
-      get(target, prop: keyof ContractDataProvider) {
+    return new Proxy(contractStore, {
+      get(target, prop: keyof ContractStore) {
         switch (prop) {
           case 'getContractInstance': {
             return async (address: AztecAddress) => {
@@ -52,6 +52,23 @@ export class ProxiedContractDataProviderFactory {
               }
             };
           }
+          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') {

package/src/debug/pxe_debug_utils.ts

@@ -0,0 +1,48 @@
+import type { NoteDao, NotesFilter } from '@aztec/stdlib/note';
+
+import type { PXE } from '../pxe.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.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 | undefined = undefined;
+
+  constructor(
+    private contractStore: ContractStore,
+    private noteStore: NoteStore,
+  ) {}
+
+  /**
+   * Not injected through constructor since they're are co-dependant.
+   */
+  public setPXE(pxe: PXE) {
+    this.#pxe = pxe;
+  }
+
+  /**
+   * 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[]> {
+    if (!this.#pxe) {
+      throw new Error('Cannot getNotes because no PXE is set');
+    }
+
+    // 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_private_state', [], filter.contractAddress);
+    await this.#pxe.simulateUtility(call);
+
+    return this.noteStore.getNotes(filter);
+  }
+}

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

@@ -3,5 +3,4 @@ export * from '../../../config/index.js';
 export * from '../../../error_enriching.js';
 export * from '../../../storage/index.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../../contract_function_simulator/pxe_oracle_interface.js';
 export type { PXECreationOptions } from '../../pxe_creation_options.js';

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

@@ -1,5 +1,6 @@
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { BBPrivateKernelProver } from '@aztec/bb-prover/client';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
@@ -44,12 +45,17 @@ export async function createPXE(
 
   const store = options.store ?? (await createStore('pxe_data', configWithContracts, storeLogger));
 
-  const simulator = new WASMSimulator();
+  const simulator = options.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);
+  let prover;
+  if (options.proverOrOptions instanceof BBPrivateKernelProver) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBBundlePrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
   const protocolContractsProvider = new BundledProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));

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

@@ -3,5 +3,4 @@ export * from '../../../config/index.js';
 export * from '../../../storage/index.js';
 export * from '../../../error_enriching.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../../contract_function_simulator/pxe_oracle_interface.js';
 export { type PXECreationOptions } from '../../pxe_creation_options.js';