@aztec/pxe 1.2.1 → 2.0.0-nightly.20250813

package/src/contract_function_simulator/oracle/private_execution.ts

@@ -19,9 +19,9 @@ import {
 } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstance } from '@aztec/stdlib/contract';
+import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
-import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
 import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import { BlockHeader, PrivateCallExecutionResult } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
@@ -32,6 +32,11 @@ import type { PrivateExecutionOracle } from './private_execution_oracle.js';
 
 /**
  * Execute a private function and return the execution result.
+ * This does not execute any kernel circuits; only the user functions.
+ *
+ * If this private function execution results in any nested private function calls,
+ * those nested calls are made via oracle calls to the `privateCallPrivateFunction` oracle,
+ * which in turn makes corresponding further calls to this function.
  */
 export async function executePrivateFunction(
   simulator: CircuitSimulator,
@@ -77,21 +82,21 @@ export async function executePrivateFunction(
 
   const contractClassLogs = privateExecutionOracle.getContractClassLogs();
 
-  const rawReturnValues = await privateExecutionOracle.loadFromExecutionCache(publicInputs.returnsHash);
+  const rawReturnValues = await privateExecutionOracle.privateLoadFromExecutionCache(publicInputs.returnsHash);
 
   const noteHashLeafIndexMap = privateExecutionOracle.getNoteHashLeafIndexMap();
   const newNotes = privateExecutionOracle.getNewNotes();
   const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
   const offchainEffects = privateExecutionOracle.getOffchainEffects();
-  const nestedExecutions = privateExecutionOracle.getNestedExecutions();
+  const nestedExecutionResults = privateExecutionOracle.getNestedExecutionResults();
 
-  let timerSubtractionList = nestedExecutions;
+  let timerSubtractionList = nestedExecutionResults;
   let witgenTime = duration;
 
   // Due to the recursive nature of execution, we have to subtract the time taken by nested calls
   while (timerSubtractionList.length > 0) {
     witgenTime -= timerSubtractionList.reduce((acc, nested) => acc + (nested.profileResult?.timings.witgen ?? 0), 0);
-    timerSubtractionList = timerSubtractionList.flatMap(nested => nested.nestedExecutions ?? []);
+    timerSubtractionList = timerSubtractionList.flatMap(nested => nested.nestedExecutionResults ?? []);
   }
 
   log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
@@ -106,7 +111,7 @@ export async function executePrivateFunction(
     noteHashNullifierCounterMap,
     rawReturnValues,
     offchainEffects,
-    nestedExecutions,
+    nestedExecutionResults,
     contractClassLogs,
     {
       timings: {
@@ -147,8 +152,8 @@ export function extractPrivateCircuitPublicInputs(
  * @param contractAddress - The address of the contract to read the class id for.
  * @param instance - The instance of the contract.
  * @param executionDataProvider - The execution data provider.
- * @param blockNumber - The block number at which to load the SharedMutable storing the class id.
- * @param timestamp - The timestamp at which to obtain the class id from the SharedMutable.
+ * @param blockNumber - The block number at which to load the DelayedPublicMutable storing the class id.
+ * @param timestamp - The timestamp at which to obtain the class id from the DelayedPublicMutable.
  * @returns The current class id.
  */
 export async function readCurrentClassId(
@@ -158,11 +163,11 @@ export async function readCurrentClassId(
   blockNumber: number,
   timestamp: UInt64,
 ) {
-  const { sharedMutableSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-  const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, slot =>
-    executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceDeployer, slot),
+  const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
+  const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, slot =>
+    executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceRegistry, slot),
   );
-  let currentClassId = sharedMutableValues.svc.getCurrentAt(timestamp)[0];
+  let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
   if (currentClassId.isZero()) {
     currentClassId = instance.originalContractClassId;
   }

package/src/contract_function_simulator/oracle/private_execution_oracle.ts

@@ -60,7 +60,8 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
   private noteHashNullifierCounterMap: Map<number, number> = new Map();
   private contractClassLogs: CountedContractClassLog[] = [];
   private offchainEffects: { data: Fr[] }[] = [];
-  private nestedExecutions: PrivateCallExecutionResult[] = [];
+  private nestedExecutionResults: PrivateCallExecutionResult[] = [];
+  private senderForTags?: AztecAddress;
 
   constructor(
     private readonly argsHash: Fr,
@@ -79,8 +80,10 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
     protected sideEffectCounter: number = 0,
     log = createLogger('simulator:client_execution_context'),
     scopes?: AztecAddress[],
+    senderForTags?: AztecAddress,
   ) {
     super(callContext.contractAddress, authWitnesses, capsules, executionDataProvider, log, scopes);
+    this.senderForTags = senderForTags;
   }
 
   // We still need this function until we can get user-defined ordering of structs for fn arguments
@@ -150,8 +153,38 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
   /**
    * Return the nested execution results during this execution.
    */
-  public getNestedExecutions() {
-    return this.nestedExecutions;
+  public getNestedExecutionResults() {
+    return this.nestedExecutionResults;
+  }
+
+  /**
+   * Get the sender for tags.
+   *
+   * This unconstrained value is used as the sender when computing an unconstrained shared secret
+   * for a tag in order to emit a log. Constrained tagging should not use this as there is no
+   * guarantee that the recipient knows about the sender, and hence about the shared secret.
+   *
+   * The value persists through nested calls, meaning all calls down the stack will use the same
+   * 'senderForTags' value (unless it is replaced).
+   */
+  public override privateGetSenderForTags(): Promise<AztecAddress | undefined> {
+    return Promise.resolve(this.senderForTags);
+  }
+
+  /**
+   * Set the sender for tags.
+   *
+   * This unconstrained value is used as the sender when computing an unconstrained shared secret
+   * for a tag in order to emit a log. Constrained tagging should not use this as there is no
+   * guarantee that the recipient knows about the sender, and hence about the shared secret.
+   *
+   * Account contracts typically set this value before calling other contracts. The value persists
+   * through nested calls, meaning all calls down the stack will use the same 'senderForTags'
+   * value (unless it is replaced by another call to this setter).
+   */
+  public override privateSetSenderForTags(senderForTags: AztecAddress): Promise<void> {
+    this.senderForTags = senderForTags;
+    return Promise.resolve();
   }
 
   /**
@@ -159,7 +192,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param values - Values to store.
    * @returns The hash of the values.
    */
-  public override storeInExecutionCache(values: Fr[], hash: Fr) {
+  public override privateStoreInExecutionCache(values: Fr[], hash: Fr) {
     return this.executionCache.store(values, hash);
   }
 
@@ -168,7 +201,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param hash - Hash of the values.
    * @returns The values.
    */
-  public override loadFromExecutionCache(hash: Fr): Promise<Fr[]> {
+  public override privateLoadFromExecutionCache(hash: Fr): Promise<Fr[]> {
     const preimage = this.executionCache.getPreimage(hash);
     if (!preimage) {
       throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
@@ -196,7 +229,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param status - The status of notes to fetch.
    * @returns Array of note data.
    */
-  public override async getNotes(
+  public override async utilityGetNotes(
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -274,7 +307,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param noteHash - A hash of the new note.
    * @returns
    */
-  public override notifyCreatedNote(
+  public override privateNotifyCreatedNote(
     storageSlot: Fr,
     noteTypeId: NoteSelector,
     noteItems: Fr[],
@@ -309,7 +342,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
    * @param noteHash - A hash of the new note.
    */
-  public override async notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
+  public override async privateNotifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
     const nullifiedNoteHashCounter = await this.noteCache.nullifyNote(
       this.callContext.contractAddress,
       innerNullifier,
@@ -326,7 +359,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
    * @param noteHash - A hash of the new note.
    */
-  public override notifyCreatedNullifier(innerNullifier: Fr) {
+  public override privateNotifyCreatedNullifier(innerNullifier: Fr) {
     return this.noteCache.nullifierCreated(this.callContext.contractAddress, innerNullifier);
   }
 
@@ -337,21 +370,21 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param log - The contract class log to be emitted.
    * @param counter - The contract class log's counter.
    */
-  public override notifyCreatedContractClassLog(log: ContractClassLog, counter: number) {
+  public override privateNotifyCreatedContractClassLog(log: ContractClassLog, counter: number) {
     this.contractClassLogs.push(new CountedContractClassLog(log, counter));
     const text = log.toBuffer().toString('hex');
     this.log.verbose(
-      `Emitted log from ContractClassRegisterer: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`,
+      `Emitted log from ContractClassRegistry: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`,
     );
   }
 
   #checkValidStaticCall(childExecutionResult: PrivateCallExecutionResult) {
     if (
-      childExecutionResult.publicInputs.noteHashes.some(item => !item.isEmpty()) ||
-      childExecutionResult.publicInputs.nullifiers.some(item => !item.isEmpty()) ||
-      childExecutionResult.publicInputs.l2ToL1Msgs.some(item => !item.isEmpty()) ||
-      childExecutionResult.publicInputs.privateLogs.some(item => !item.isEmpty()) ||
-      childExecutionResult.publicInputs.contractClassLogsHashes.some(item => !item.isEmpty())
+      childExecutionResult.publicInputs.noteHashes.claimedLength > 0 ||
+      childExecutionResult.publicInputs.nullifiers.claimedLength > 0 ||
+      childExecutionResult.publicInputs.l2ToL1Msgs.claimedLength > 0 ||
+      childExecutionResult.publicInputs.privateLogs.claimedLength > 0 ||
+      childExecutionResult.publicInputs.contractClassLogsHashes.claimedLength > 0
     ) {
       throw new Error(`Static call cannot update the state, emit L2->L1 messages or generate logs`);
     }
@@ -366,7 +399,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param isStaticCall - Whether the call is a static call.
    * @returns The execution result.
    */
-  override async callPrivateFunction(
+  override async privateCallPrivateFunction(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
@@ -406,6 +439,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
       sideEffectCounter,
       this.log,
       this.scopes,
+      this.senderForTags,
     );
 
     const setupTime = simulatorSetupTimer.ms();
@@ -422,7 +456,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
       this.#checkValidStaticCall(childExecutionResult);
     }
 
-    this.nestedExecutions.push(childExecutionResult);
+    this.nestedExecutionResults.push(childExecutionResult);
 
     const publicInputs = childExecutionResult.publicInputs;
 
@@ -456,7 +490,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param sideEffectCounter - The side effect counter at the start of the call.
    * @param isStaticCall - Whether the call is a static call.
    */
-  public override notifyEnqueuedPublicFunctionCall(
+  public override privateNotifyEnqueuedPublicFunctionCall(
     _targetContractAddress: AztecAddress,
     calldataHash: Fr,
     _sideEffectCounter: number,
@@ -473,7 +507,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
    * @param sideEffectCounter - The side effect counter at the start of the call.
    * @param isStaticCall - Whether the call is a static call.
    */
-  public override notifySetPublicTeardownFunctionCall(
+  public override privateNotifySetPublicTeardownFunctionCall(
     _targetContractAddress: AztecAddress,
     calldataHash: Fr,
     _sideEffectCounter: number,
@@ -483,7 +517,9 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
     return Promise.resolve();
   }
 
-  public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void> {
+  public override privateNotifySetMinRevertibleSideEffectCounter(
+    minRevertibleSideEffectCounter: number,
+  ): Promise<void> {
     return this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
   }
 
@@ -511,17 +547,17 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle {
     return this.executionDataProvider.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
   }
 
-  public override async incrementAppTaggingSecretIndexAsSender(sender: AztecAddress, recipient: AztecAddress) {
+  public override async privateIncrementAppTaggingSecretIndexAsSender(sender: AztecAddress, recipient: AztecAddress) {
     await this.executionDataProvider.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
   }
 
-  public override async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
+  public override async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
     await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
   }
 
-  public override emitOffchainEffect(data: Fr[]): Promise<void> {
+  public override utilityEmitOffchainEffect(data: Fr[]): Promise<void> {
     this.offchainEffects.push({ data });
     return Promise.resolve();
   }

package/src/contract_function_simulator/oracle/typed_oracle.ts

@@ -16,15 +16,15 @@ import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
  * Information about a note needed during execution.
  */
 export interface NoteData {
-  /** The note. */
+  /** The actual note content (the fields of the Noir #[note] struct). */
   note: Note;
-  /** The contract address of the note. */
+  /** The address of the contract that owns the note. */
   contractAddress: AztecAddress;
   /** The storage slot of the note. */
   storageSlot: Fr;
-  /** The nonce of the note. */
+  /** The nonce injected into the note hash preimage by kernels. */
   noteNonce: Fr;
-  /** A hash of the note. */
+  /** A hash of the note as it gets stored in the note hash tree. */
   noteHash: Fr;
   /** The corresponding nullifier of the note. Undefined for pending notes. */
   siloedNullifier?: Fr;
@@ -44,78 +44,81 @@ class OracleMethodNotAvailableError extends Error {
  * and are unavailable by default.
  */
 export abstract class TypedOracle {
-  getRandomField(): Fr {
-    return Fr.random();
+  utilityGetRandomField(): Fr {
+    throw new OracleMethodNotAvailableError('utilityGetRandomField');
   }
 
-  storeInExecutionCache(_values: Fr[], _hash: Fr): void {
-    throw new OracleMethodNotAvailableError('storeInExecutionCache');
+  privateStoreInExecutionCache(_values: Fr[], _hash: Fr): void {
+    throw new OracleMethodNotAvailableError('privateStoreInExecutionCache');
   }
 
-  loadFromExecutionCache(_hash: Fr): Promise<Fr[]> {
-    return Promise.reject(new OracleMethodNotAvailableError('loadFromExecutionCache'));
+  privateLoadFromExecutionCache(_hash: Fr): Promise<Fr[]> {
+    return Promise.reject(new OracleMethodNotAvailableError('privateLoadFromExecutionCache'));
   }
 
-  getBlockNumber(): Promise<number> {
-    return Promise.reject(new OracleMethodNotAvailableError('getBlockNumber'));
+  utilityGetBlockNumber(): Promise<number> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetBlockNumber'));
   }
 
-  getTimestamp(): Promise<UInt64> {
-    return Promise.reject(new OracleMethodNotAvailableError('getTimestamp'));
+  utilityGetTimestamp(): Promise<UInt64> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetTimestamp'));
   }
 
-  getContractAddress(): Promise<AztecAddress> {
-    return Promise.reject(new OracleMethodNotAvailableError('getContractAddress'));
+  utilityGetContractAddress(): Promise<AztecAddress> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetContractAddress'));
   }
 
-  getChainId(): Promise<Fr> {
-    return Promise.reject(new OracleMethodNotAvailableError('getChainId'));
+  utilityGetChainId(): Promise<Fr> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetChainId'));
   }
 
-  getVersion(): Promise<Fr> {
-    return Promise.reject(new OracleMethodNotAvailableError('getVersion'));
+  utilityGetVersion(): Promise<Fr> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetVersion'));
   }
 
-  getKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest> {
-    return Promise.reject(new OracleMethodNotAvailableError('getKeyValidationRequest'));
+  utilityGetKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetKeyValidationRequest'));
   }
 
-  getContractInstance(_address: AztecAddress): Promise<ContractInstance> {
-    return Promise.reject(new OracleMethodNotAvailableError('getContractInstance'));
+  utilityGetContractInstance(_address: AztecAddress): Promise<ContractInstance> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetContractInstance'));
   }
 
-  getMembershipWitness(_blockNumber: number, _treeId: MerkleTreeId, _leafValue: Fr): Promise<Fr[] | undefined> {
-    return Promise.reject(new OracleMethodNotAvailableError('getMembershipWitness'));
+  utilityGetMembershipWitness(_blockNumber: number, _treeId: MerkleTreeId, _leafValue: Fr): Promise<Fr[] | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetMembershipWitness'));
   }
 
-  getNullifierMembershipWitness(_blockNumber: number, _nullifier: Fr): Promise<NullifierMembershipWitness | undefined> {
-    return Promise.reject(new OracleMethodNotAvailableError('getNullifierMembershipWitness'));
+  utilityGetNullifierMembershipWitness(
+    _blockNumber: number,
+    _nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetNullifierMembershipWitness'));
   }
 
-  getPublicDataWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    return Promise.reject(new OracleMethodNotAvailableError('getPublicDataWitness'));
+  utilityGetPublicDataWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetPublicDataWitness'));
   }
 
-  getLowNullifierMembershipWitness(
+  utilityGetLowNullifierMembershipWitness(
     _blockNumber: number,
     _nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    return Promise.reject(new OracleMethodNotAvailableError('getLowNullifierMembershipWitness'));
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetLowNullifierMembershipWitness'));
   }
 
-  getBlockHeader(_blockNumber: number): Promise<BlockHeader | undefined> {
-    return Promise.reject(new OracleMethodNotAvailableError('getBlockHeader'));
+  utilityGetBlockHeader(_blockNumber: number): Promise<BlockHeader | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetBlockHeader'));
   }
 
-  getCompleteAddress(_account: AztecAddress): Promise<CompleteAddress> {
-    return Promise.reject(new OracleMethodNotAvailableError('getCompleteAddress'));
+  utilityGetCompleteAddress(_account: AztecAddress): Promise<CompleteAddress> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetCompleteAddress'));
   }
 
-  getAuthWitness(_messageHash: Fr): Promise<Fr[] | undefined> {
-    return Promise.reject(new OracleMethodNotAvailableError('getAuthWitness'));
+  utilityGetAuthWitness(_messageHash: Fr): Promise<Fr[] | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetAuthWitness'));
   }
 
-  getNotes(
+  utilityGetNotes(
     _storageSlot: Fr,
     _numSelects: number,
     _selectByIndexes: number[],
@@ -131,139 +134,152 @@ export abstract class TypedOracle {
     _offset: number,
     _status: NoteStatus,
   ): Promise<NoteData[]> {
-    return Promise.reject(new OracleMethodNotAvailableError('getNotes'));
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetNotes'));
   }
 
-  notifyCreatedNote(_storageSlot: Fr, _noteTypeId: NoteSelector, _note: Fr[], _noteHash: Fr, _counter: number): void {
-    throw new OracleMethodNotAvailableError('notifyCreatedNote');
+  privateNotifyCreatedNote(
+    _storageSlot: Fr,
+    _noteTypeId: NoteSelector,
+    _note: Fr[],
+    _noteHash: Fr,
+    _counter: number,
+  ): void {
+    throw new OracleMethodNotAvailableError('privateNotifyCreatedNote');
   }
 
-  notifyNullifiedNote(_innerNullifier: Fr, _noteHash: Fr, _counter: number): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('notifyNullifiedNote'));
+  privateNotifyNullifiedNote(_innerNullifier: Fr, _noteHash: Fr, _counter: number): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('privateNotifyNullifiedNote'));
   }
 
-  notifyCreatedNullifier(_innerNullifier: Fr): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('notifyCreatedNullifier'));
+  privateNotifyCreatedNullifier(_innerNullifier: Fr): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('privateNotifyCreatedNullifier'));
   }
 
-  checkNullifierExists(_innerNullifier: Fr): Promise<boolean> {
-    return Promise.reject(new OracleMethodNotAvailableError('checkNullifierExists'));
+  utilityCheckNullifierExists(_innerNullifier: Fr): Promise<boolean> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityCheckNullifierExists'));
   }
 
-  getL1ToL2MembershipWitness(
+  utilityGetL1ToL2MembershipWitness(
     _contractAddress: AztecAddress,
     _messageHash: Fr,
     _secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    return Promise.reject(new OracleMethodNotAvailableError('getL1ToL2MembershipWitness'));
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetL1ToL2MembershipWitness'));
   }
 
-  storageRead(
+  utilityStorageRead(
     _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'));
+    return Promise.reject(new OracleMethodNotAvailableError('utilityStorageRead'));
   }
 
-  notifyCreatedContractClassLog(_log: ContractClassLog, _counter: number): void {
-    throw new OracleMethodNotAvailableError('notifyCreatedContractClassLog');
+  privateNotifyCreatedContractClassLog(_log: ContractClassLog, _counter: number): void {
+    throw new OracleMethodNotAvailableError('privateNotifyCreatedContractClassLog');
   }
 
-  callPrivateFunction(
+  privateCallPrivateFunction(
     _targetContractAddress: AztecAddress,
     _functionSelector: FunctionSelector,
     _argsHash: Fr,
     _sideEffectCounter: number,
     _isStaticCall: boolean,
   ): Promise<{ endSideEffectCounter: Fr; returnsHash: Fr }> {
-    return Promise.reject(new OracleMethodNotAvailableError('callPrivateFunction'));
+    return Promise.reject(new OracleMethodNotAvailableError('privateCallPrivateFunction'));
   }
 
-  notifyEnqueuedPublicFunctionCall(
+  privateNotifyEnqueuedPublicFunctionCall(
     _targetContractAddress: AztecAddress,
     _calldataHash: Fr,
     _sideEffectCounter: number,
     _isStaticCall: boolean,
   ): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('notifyEnqueuedPublicFunctionCall'));
+    return Promise.reject(new OracleMethodNotAvailableError('privateNotifyEnqueuedPublicFunctionCall'));
   }
 
-  notifySetPublicTeardownFunctionCall(
+  privateNotifySetPublicTeardownFunctionCall(
     _targetContractAddress: AztecAddress,
     _calldataHash: Fr,
     _sideEffectCounter: number,
     _isStaticCall: boolean,
   ): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('notifySetPublicTeardownFunctionCall'));
+    return Promise.reject(new OracleMethodNotAvailableError('privateNotifySetPublicTeardownFunctionCall'));
   }
 
-  notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): Promise<void> {
-    throw new OracleMethodNotAvailableError('notifySetMinRevertibleSideEffectCounter');
+  privateNotifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): Promise<void> {
+    throw new OracleMethodNotAvailableError('privateNotifySetMinRevertibleSideEffectCounter');
   }
 
-  debugLog(_message: string, _fields: Fr[]): void {
-    throw new OracleMethodNotAvailableError('debugLog');
+  utilityDebugLog(_message: string, _fields: Fr[]): void {
+    throw new OracleMethodNotAvailableError('utilityDebugLog');
   }
 
-  getIndexedTaggingSecretAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<IndexedTaggingSecret> {
-    return Promise.reject(new OracleMethodNotAvailableError('getIndexedTaggingSecretAsSender'));
+  utilityGetIndexedTaggingSecretAsSender(
+    _sender: AztecAddress,
+    _recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetIndexedTaggingSecretAsSender'));
   }
 
-  incrementAppTaggingSecretIndexAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('incrementAppTaggingSecretIndexAsSender'));
+  privateIncrementAppTaggingSecretIndexAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('privateIncrementAppTaggingSecretIndexAsSender'));
   }
 
-  fetchTaggedLogs(_pendingTaggedLogArrayBaseSlot: Fr): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('fetchTaggedLogs'));
+  utilityFetchTaggedLogs(_pendingTaggedLogArrayBaseSlot: Fr): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityFetchTaggedLogs'));
   }
 
-  validateEnqueuedNotesAndEvents(
+  utilityValidateEnqueuedNotesAndEvents(
     _contractAddress: AztecAddress,
     _noteValidationRequestsArrayBaseSlot: Fr,
     _eventValidationRequestsArrayBaseSlot: Fr,
   ): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('validateEnqueuedNotesAndEvents'));
+    return Promise.reject(new OracleMethodNotAvailableError('utilityValidateEnqueuedNotesAndEvents'));
   }
 
-  bulkRetrieveLogs(
+  utilityBulkRetrieveLogs(
     _contractAddress: AztecAddress,
     _logRetrievalRequestsArrayBaseSlot: Fr,
     _logRetrievalResponsesArrayBaseSlot: Fr,
   ): Promise<void> {
-    throw new OracleMethodNotAvailableError('bulkRetrieveLogs');
+    throw new OracleMethodNotAvailableError('utilityBulkRetrieveLogs');
+  }
+
+  utilityStoreCapsule(_contractAddress: AztecAddress, _key: Fr, _capsule: Fr[]): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityStoreCapsule'));
+  }
+
+  utilityLoadCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<Fr[] | null> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityLoadCapsule'));
   }
 
-  storeCapsule(_contractAddress: AztecAddress, _key: Fr, _capsule: Fr[]): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('storeCapsule'));
+  utilityDeleteCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityDeleteCapsule'));
   }
 
-  loadCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<Fr[] | null> {
-    return Promise.reject(new OracleMethodNotAvailableError('loadCapsule'));
+  utilityCopyCapsule(_contractAddress: AztecAddress, _srcKey: Fr, _dstKey: Fr, _numEntries: number): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityCopyCapsule'));
   }
 
-  deleteCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('deleteCapsule'));
+  utilityAes128Decrypt(_ciphertext: Buffer, _iv: Buffer, _symKey: Buffer): Promise<Buffer> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityAes128Decrypt'));
   }
 
-  copyCapsule(_contractAddress: AztecAddress, _srcKey: Fr, _dstKey: Fr, _numEntries: number): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('copyCapsule'));
+  utilityGetSharedSecret(_address: AztecAddress, _ephPk: Point): Promise<Point> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityGetSharedSecret'));
   }
 
-  aes128Decrypt(_ciphertext: Buffer, _iv: Buffer, _symKey: Buffer): Promise<Buffer> {
-    return Promise.reject(new OracleMethodNotAvailableError('aes128Decrypt'));
+  utilityEmitOffchainEffect(_data: Fr[]): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('utilityEmitOffchainEffect'));
   }
 
-  getSharedSecret(_address: AztecAddress, _ephPk: Point): Promise<Point> {
-    return Promise.reject(new OracleMethodNotAvailableError('getSharedSecret'));
+  privateGetSenderForTags(): Promise<AztecAddress | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('privateGetSenderForTags'));
   }
 
-  emitOffchainEffect(_data: Fr[]): Promise<void> {
-    return Promise.reject(new OracleMethodNotAvailableError('emitOffchainEffect'));
+  privateSetSenderForTags(_senderForTags: AztecAddress): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('privateSetSenderForTags'));
   }
 }