@aztec/pxe 0.87.5 → 0.87.7

package/src/contract_function_simulator/oracle/typed_oracle.ts

@@ -0,0 +1,273 @@
+import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import { Fr, Point } from '@aztec/foundation/fields';
+import type { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import type { ContractClassLog, IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
+import type { Note, NoteStatus } from '@aztec/stdlib/note';
+import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+
+import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
+
+/**
+ * Information about a note needed during execution.
+ */
+export interface NoteData {
+  /** The note. */
+  note: Note;
+  /** The contract address of the note. */
+  contractAddress: AztecAddress;
+  /** The storage slot of the note. */
+  storageSlot: Fr;
+  /** The nonce of the note. */
+  nonce: Fr;
+  /** A hash of the note. */
+  noteHash: Fr;
+  /** The corresponding nullifier of the note. Undefined for pending notes. */
+  siloedNullifier?: Fr;
+  /** The note's leaf index in the note hash tree. Undefined for pending notes. */
+  index?: bigint;
+}
+
+class OracleMethodNotAvailableError extends Error {
+  constructor(methodName: string) {
+    super(`Oracle method ${methodName} is not available.`);
+  }
+}
+
+/**
+ * Oracle with typed parameters and typed return values.
+ * Methods that require read and/or write will have to be implemented based on the context (public, private, or view)
+ * and are unavailable by default.
+ */
+export abstract class TypedOracle {
+  getRandomField(): Fr {
+    return Fr.random();
+  }
+
+  storeInExecutionCache(_values: Fr[], _hash: Fr): void {
+    throw new OracleMethodNotAvailableError('storeInExecutionCache');
+  }
+
+  loadFromExecutionCache(_hash: Fr): Promise<Fr[]> {
+    return Promise.reject(new OracleMethodNotAvailableError('loadFromExecutionCache'));
+  }
+
+  getBlockNumber(): Promise<number> {
+    return Promise.reject(new OracleMethodNotAvailableError('getBlockNumber'));
+  }
+
+  getContractAddress(): Promise<AztecAddress> {
+    return Promise.reject(new OracleMethodNotAvailableError('getContractAddress'));
+  }
+
+  getChainId(): Promise<Fr> {
+    return Promise.reject(new OracleMethodNotAvailableError('getChainId'));
+  }
+
+  getVersion(): Promise<Fr> {
+    return Promise.reject(new OracleMethodNotAvailableError('getVersion'));
+  }
+
+  getKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest> {
+    return Promise.reject(new OracleMethodNotAvailableError('getKeyValidationRequest'));
+  }
+
+  getContractInstance(_address: AztecAddress): Promise<ContractInstance> {
+    return Promise.reject(new OracleMethodNotAvailableError('getContractInstance'));
+  }
+
+  getMembershipWitness(_blockNumber: number, _treeId: MerkleTreeId, _leafValue: Fr): Promise<Fr[] | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('getMembershipWitness'));
+  }
+
+  getNullifierMembershipWitness(_blockNumber: number, _nullifier: Fr): Promise<NullifierMembershipWitness | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('getNullifierMembershipWitness'));
+  }
+
+  getPublicDataWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('getPublicDataWitness'));
+  }
+
+  getLowNullifierMembershipWitness(
+    _blockNumber: number,
+    _nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('getLowNullifierMembershipWitness'));
+  }
+
+  getBlockHeader(_blockNumber: number): Promise<BlockHeader | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('getBlockHeader'));
+  }
+
+  getCompleteAddress(_account: AztecAddress): Promise<CompleteAddress> {
+    return Promise.reject(new OracleMethodNotAvailableError('getCompleteAddress'));
+  }
+
+  getAuthWitness(_messageHash: Fr): Promise<Fr[] | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('getAuthWitness'));
+  }
+
+  getNotes(
+    _storageSlot: Fr,
+    _numSelects: number,
+    _selectByIndexes: number[],
+    _selectByOffsets: number[],
+    _selectByLengths: number[],
+    _selectValues: Fr[],
+    _selectComparators: number[],
+    _sortByIndexes: number[],
+    _sortByOffsets: number[],
+    _sortByLengths: number[],
+    _sortOrder: number[],
+    _limit: number,
+    _offset: number,
+    _status: NoteStatus,
+  ): Promise<NoteData[]> {
+    return Promise.reject(new OracleMethodNotAvailableError('getNotes'));
+  }
+
+  notifyCreatedNote(_storageSlot: Fr, _noteTypeId: NoteSelector, _note: Fr[], _noteHash: Fr, _counter: number): void {
+    throw new OracleMethodNotAvailableError('notifyCreatedNote');
+  }
+
+  notifyNullifiedNote(_innerNullifier: Fr, _noteHash: Fr, _counter: number): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('notifyNullifiedNote'));
+  }
+
+  notifyCreatedNullifier(_innerNullifier: Fr): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('notifyCreatedNullifier'));
+  }
+
+  checkNullifierExists(_innerNullifier: Fr): Promise<boolean> {
+    return Promise.reject(new OracleMethodNotAvailableError('checkNullifierExists'));
+  }
+
+  getL1ToL2MembershipWitness(
+    _contractAddress: AztecAddress,
+    _messageHash: Fr,
+    _secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
+    return Promise.reject(new OracleMethodNotAvailableError('getL1ToL2MembershipWitness'));
+  }
+
+  storageRead(
+    _contractAddress: AztecAddress,
+    _startStorageSlot: Fr,
+    _blockNumber: number,
+    _numberOfElements: number,
+  ): Promise<Fr[]> {
+    return Promise.reject(new OracleMethodNotAvailableError('storageRead'));
+  }
+
+  storageWrite(_startStorageSlot: Fr, _values: Fr[]): Promise<Fr[]> {
+    return Promise.reject(new OracleMethodNotAvailableError('storageWrite'));
+  }
+
+  notifyCreatedContractClassLog(_log: ContractClassLog, _counter: number): void {
+    throw new OracleMethodNotAvailableError('notifyCreatedContractClassLog');
+  }
+
+  callPrivateFunction(
+    _targetContractAddress: AztecAddress,
+    _functionSelector: FunctionSelector,
+    _argsHash: Fr,
+    _sideEffectCounter: number,
+    _isStaticCall: boolean,
+  ): Promise<{ endSideEffectCounter: Fr; returnsHash: Fr }> {
+    return Promise.reject(new OracleMethodNotAvailableError('callPrivateFunction'));
+  }
+
+  notifyEnqueuedPublicFunctionCall(
+    _targetContractAddress: AztecAddress,
+    _calldataHash: Fr,
+    _sideEffectCounter: number,
+    _isStaticCall: boolean,
+  ): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('notifyEnqueuedPublicFunctionCall'));
+  }
+
+  notifySetPublicTeardownFunctionCall(
+    _targetContractAddress: AztecAddress,
+    _calldataHash: Fr,
+    _sideEffectCounter: number,
+    _isStaticCall: boolean,
+  ): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('notifySetPublicTeardownFunctionCall'));
+  }
+
+  notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): Promise<void> {
+    throw new OracleMethodNotAvailableError('notifySetMinRevertibleSideEffectCounter');
+  }
+
+  debugLog(_message: string, _fields: Fr[]): void {
+    throw new OracleMethodNotAvailableError('debugLog');
+  }
+
+  getIndexedTaggingSecretAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<IndexedTaggingSecret> {
+    return Promise.reject(new OracleMethodNotAvailableError('getIndexedTaggingSecretAsSender'));
+  }
+
+  incrementAppTaggingSecretIndexAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('incrementAppTaggingSecretIndexAsSender'));
+  }
+
+  fetchTaggedLogs(_pendingTaggedLogArrayBaseSlot: Fr): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('fetchTaggedLogs'));
+  }
+
+  deliverNote(
+    _contractAddress: AztecAddress,
+    _storageSlot: Fr,
+    _nonce: Fr,
+    _content: Fr[],
+    _noteHash: Fr,
+    _nullifier: Fr,
+    _txHash: TxHash,
+    _recipient: AztecAddress,
+  ): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('deliverNote'));
+  }
+
+  getLogByTag(_tag: Fr): Promise<LogWithTxData | null> {
+    throw new OracleMethodNotAvailableError('getLogByTag');
+  }
+
+  storeCapsule(_contractAddress: AztecAddress, _key: Fr, _capsule: Fr[]): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('storeCapsule'));
+  }
+
+  loadCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<Fr[] | null> {
+    return Promise.reject(new OracleMethodNotAvailableError('loadCapsule'));
+  }
+
+  deleteCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('deleteCapsule'));
+  }
+
+  copyCapsule(_contractAddress: AztecAddress, _srcKey: Fr, _dstKey: Fr, _numEntries: number): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('copyCapsule'));
+  }
+
+  aes128Decrypt(_ciphertext: Buffer, _iv: Buffer, _symKey: Buffer): Promise<Buffer> {
+    return Promise.reject(new OracleMethodNotAvailableError('aes128Decrypt'));
+  }
+
+  getSharedSecret(_address: AztecAddress, _ephPk: Point): Promise<Point> {
+    return Promise.reject(new OracleMethodNotAvailableError('getSharedSecret'));
+  }
+
+  storePrivateEventLog(
+    _contractAddress: AztecAddress,
+    _recipient: AztecAddress,
+    _eventSelector: EventSelector,
+    _logContent: Fr[],
+    _txHash: TxHash,
+    _logIndexInTx: number,
+    _txIndexInBlock: number,
+  ): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('storePrivateEventLog'));
+  }
+}

package/src/contract_function_simulator/oracle/utility_execution_oracle.ts

@@ -0,0 +1,384 @@
+import { Aes128 } from '@aztec/foundation/crypto';
+import { Fr, Point } from '@aztec/foundation/fields';
+import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import type { EventSelector } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import { IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
+import type { NoteStatus } from '@aztec/stdlib/note';
+import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import type { BlockHeader, Capsule, TxHash } from '@aztec/stdlib/tx';
+
+import type { ExecutionDataProvider } from '../execution_data_provider.js';
+import { pickNotes } from '../pick_notes.js';
+import { type NoteData, TypedOracle } from './typed_oracle.js';
+
+/**
+ * The oracle for an execution of utility contract functions.
+ */
+export class UtilityExecutionOracle extends TypedOracle {
+  constructor(
+    protected readonly contractAddress: AztecAddress,
+    /** 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 log = createLogger('simulator:client_view_context'),
+    protected readonly scopes?: AztecAddress[],
+  ) {
+    super();
+  }
+
+  public override getBlockNumber(): Promise<number> {
+    return this.executionDataProvider.getBlockNumber();
+  }
+
+  public override getContractAddress(): Promise<AztecAddress> {
+    return Promise.resolve(this.contractAddress);
+  }
+
+  public override getChainId(): Promise<Fr> {
+    return Promise.resolve(this.executionDataProvider.getChainId().then(id => new Fr(id)));
+  }
+
+  public override getVersion(): Promise<Fr> {
+    return Promise.resolve(this.executionDataProvider.getVersion().then(v => new Fr(v)));
+  }
+
+  /**
+   * Retrieve keys associated with a specific master public key and app address.
+   * @param pkMHash - The master public key hash.
+   * @returns A Promise that resolves to nullifier keys.
+   * @throws If the keys are not registered in the key store.
+   */
+  public override getKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest> {
+    return this.executionDataProvider.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 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 override getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+    return this.executionDataProvider.getMembershipWitness(blockNumber, 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 nullifier - Nullifier we try to find witness for.
+   * @returns The nullifier membership witness (if found).
+   */
+  public override async getNullifierMembershipWitness(
+    blockNumber: number,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return await this.executionDataProvider.getNullifierMembershipWitness(blockNumber, 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 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
+   * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
+   * we are trying to prove non-inclusion for.
+   */
+  public override async getLowNullifierMembershipWitness(
+    blockNumber: number,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return await this.executionDataProvider.getLowNullifierMembershipWitness(blockNumber, 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 leafSlot - The slot of the public data tree to get the witness for.
+   * @returns - The witness
+   */
+  public override async getPublicDataWitness(
+    blockNumber: number,
+    leafSlot: Fr,
+  ): Promise<PublicDataWitness | undefined> {
+    return await this.executionDataProvider.getPublicDataWitness(blockNumber, leafSlot);
+  }
+
+  /**
+   * Fetches a block header of a given block.
+   * @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 override async getBlockHeader(blockNumber: number): Promise<BlockHeader | undefined> {
+    const block = await this.executionDataProvider.getBlock(blockNumber);
+    if (!block) {
+      return undefined;
+    }
+    return block.header;
+  }
+
+  /**
+   * Retrieve the complete address associated to a given address.
+   * @param account - The account address.
+   * @returns A complete address associated with the input address.
+   * @throws An error if the account is not registered in the database.
+   */
+  public override getCompleteAddress(account: AztecAddress): Promise<CompleteAddress> {
+    return this.executionDataProvider.getCompleteAddress(account);
+  }
+
+  /**
+   * Returns a contract instance associated with an address or throws if not found.
+   * @param address - Address.
+   * @returns A contract instance.
+   */
+  public override getContractInstance(address: AztecAddress): Promise<ContractInstance> {
+    return this.executionDataProvider.getContractInstance(address);
+  }
+
+  /**
+   * Returns an auth witness for the given message hash. Checks on the list of transient witnesses
+   * for this transaction first, and falls back to the local database if not found.
+   * @param messageHash - Hash of the message to authenticate.
+   * @returns Authentication witness for the requested message hash.
+   */
+  public override getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
+    return Promise.resolve(this.authWitnesses.find(w => w.requestHash.equals(messageHash))?.witness);
+  }
+
+  /**
+   * Gets some notes for a contract address and storage slot.
+   * Returns a flattened array containing filtered notes.
+   *
+   * @remarks
+   * Check for pending notes with matching slot.
+   * Real notes coming from DB will have a leafIndex which
+   * represents their index in the note hash tree.
+   *
+   * @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.
+   * @param selectValues - The values to match.
+   * @param selectComparators - The comparators to use to match values.
+   * @param sortBy - An array of indices of the fields to sort.
+   * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
+   * @param limit - The number of notes to retrieve per query.
+   * @param offset - The starting index for pagination.
+   * @param status - The status of notes to fetch.
+   * @returns Array of note data.
+   */
+  public override async getNotes(
+    storageSlot: Fr,
+    numSelects: number,
+    selectByIndexes: number[],
+    selectByOffsets: number[],
+    selectByLengths: number[],
+    selectValues: Fr[],
+    selectComparators: number[],
+    sortByIndexes: number[],
+    sortByOffsets: number[],
+    sortByLengths: number[],
+    sortOrder: number[],
+    limit: number,
+    offset: number,
+    status: NoteStatus,
+  ): Promise<NoteData[]> {
+    const dbNotes = await this.executionDataProvider.getNotes(this.contractAddress, storageSlot, status, this.scopes);
+    return pickNotes<NoteData>(dbNotes, {
+      selects: selectByIndexes.slice(0, numSelects).map((index, i) => ({
+        selector: { index, offset: selectByOffsets[i], length: selectByLengths[i] },
+        value: selectValues[i],
+        comparator: selectComparators[i],
+      })),
+      sorts: sortByIndexes.map((index, i) => ({
+        selector: { index, offset: sortByOffsets[i], length: sortByLengths[i] },
+        order: sortOrder[i],
+      })),
+      limit,
+      offset,
+    });
+  }
+
+  /**
+   * Check if a nullifier exists in the nullifier tree.
+   * @param innerNullifier - The inner nullifier.
+   * @returns A boolean indicating whether the nullifier exists in the tree or not.
+   */
+  public override async checkNullifierExists(innerNullifier: Fr) {
+    const nullifier = await siloNullifier(this.contractAddress, innerNullifier!);
+    const index = await this.executionDataProvider.getNullifierIndex(nullifier);
+    return index !== undefined;
+  }
+
+  /**
+   * Fetches a message from the executionDataProvider, 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.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
+   */
+  public override async getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
+    return await this.executionDataProvider.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
+  }
+
+  /**
+   * Read the public storage data.
+   * @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 override async storageRead(
+    contractAddress: AztecAddress,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ) {
+    const values = [];
+    for (let i = 0n; i < numberOfElements; i++) {
+      const storageSlot = new Fr(startStorageSlot.value + i);
+      const value = await this.executionDataProvider.getPublicStorageAt(blockNumber, contractAddress, storageSlot);
+
+      this.log.debug(
+        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
+      );
+      values.push(value);
+    }
+    return values;
+  }
+
+  public override debugLog(message: string, fields: Fr[]): void {
+    this.log.verbose(`${applyStringFormatting(message, fields)}`, { module: `${this.log.module}:debug_log` });
+  }
+
+  /**
+   * Returns the tagging secret for a given sender and recipient pair, siloed to the current contract address.
+   * Includes the next index to be used used for tagging with this secret.
+   * For this to work, the ivsk_m of the sender must be known.
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   * @returns A tagging secret that can be used to tag notes.
+   */
+  public override async getIndexedTaggingSecretAsSender(
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret> {
+    return await this.executionDataProvider.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
+  }
+
+  public override async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
+    await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
+
+    await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
+  }
+
+  public override async deliverNote(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    nonce: Fr,
+    content: Fr[],
+    noteHash: Fr,
+    nullifier: Fr,
+    txHash: TxHash,
+    recipient: AztecAddress,
+  ) {
+    // TODO(#10727): allow other contracts to deliver notes
+    if (!this.contractAddress.equals(contractAddress)) {
+      throw new Error(`Got a note delivery request from ${contractAddress}, expected ${this.contractAddress}`);
+    }
+
+    await this.executionDataProvider.deliverNote(
+      contractAddress,
+      storageSlot,
+      nonce,
+      content,
+      noteHash,
+      nullifier,
+      txHash,
+      recipient,
+    );
+  }
+
+  public override getLogByTag(tag: Fr): Promise<LogWithTxData | null> {
+    return this.executionDataProvider.getLogByTag(tag);
+  }
+
+  public override storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // 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);
+  }
+
+  public override async loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // 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 (
+      // 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))
+    );
+  }
+
+  public override deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // 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);
+  }
+
+  public override copyCapsule(
+    contractAddress: AztecAddress,
+    srcSlot: Fr,
+    dstSlot: Fr,
+    numEntries: number,
+  ): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // 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);
+  }
+
+  // TODO(#11849): consider replacing this oracle with a pure Noir implementation of aes decryption.
+  public override aes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer> {
+    const aes128 = new Aes128();
+    return aes128.decryptBufferCBC(ciphertext, iv, symKey);
+  }
+
+  public override getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
+    return this.executionDataProvider.getSharedSecret(address, ephPk);
+  }
+
+  public override storePrivateEventLog(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+    eventSelector: EventSelector,
+    msgContent: Fr[],
+    txHash: TxHash,
+    logIndexInTx: number,
+    txIndexInBlock: number,
+  ): Promise<void> {
+    return this.executionDataProvider.storePrivateEventLog(
+      contractAddress,
+      recipient,
+      eventSelector,
+      msgContent,
+      txHash,
+      logIndexInTx,
+      txIndexInBlock,
+    );
+  }
+}