@aztec/pxe 0.0.1-commit.f504929 → 0.0.1-commit.f81dbcf

package/src/contract_function_simulator/oracle/oracle.ts

@@ -69,12 +69,12 @@ export class Oracle {
       name => !excludedProps.includes(name as (typeof excludedProps)[number]),
     );
 
-    // Validate oracle names - these must be prefixed with either "aztec_prv_" or "aztec_utl_" to indicate their scope
+    // Validate oracle names - these must be prefixed with either "private" or "utility" to indicate their scope
     // and must correspond to a function on the Oracle class.
     oracleNames.forEach(name => {
-      if (!name.startsWith('aztec_prv_') && !name.startsWith('aztec_utl_')) {
+      if (!name.startsWith('private') && !name.startsWith('utility')) {
         throw new Error(
-          `Oracle function "${name}" must be prefixed with either "aztec_prv_" or "aztec_utl_" to indicate its scope`,
+          `Oracle function "${name}" must be prefixed with either "private" or "utility" to indicate its scope`,
         );
       }
 
@@ -92,46 +92,41 @@ export class Oracle {
     }, {} as ACIRCallback);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_utl_assertCompatibleOracleVersion([version]: ACVMField[]) {
-    this.handlerAsMisc().assertCompatibleOracleVersion(Fr.fromString(version).toNumber());
+  utilityAssertCompatibleOracleVersion([version]: ACVMField[]) {
+    this.handlerAsMisc().utilityAssertCompatibleOracleVersion(Fr.fromString(version).toNumber());
     return Promise.resolve([]);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_utl_getRandomField(): Promise<ACVMField[]> {
-    const val = this.handlerAsMisc().getRandomField();
+  utilityGetRandomField(): Promise<ACVMField[]> {
+    const val = this.handlerAsMisc().utilityGetRandomField();
     return Promise.resolve([toACVMField(val)]);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_prv_storeInExecutionCache(values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
-    this.handlerAsPrivate().storeInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
+  privateStoreInExecutionCache(values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
+    this.handlerAsPrivate().privateStoreInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
     return Promise.resolve([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_loadFromExecutionCache([returnsHash]: ACVMField[]): Promise<ACVMField[][]> {
-    const values = await this.handlerAsPrivate().loadFromExecutionCache(Fr.fromString(returnsHash));
+  async privateLoadFromExecutionCache([returnsHash]: ACVMField[]): Promise<ACVMField[][]> {
+    const values = await this.handlerAsPrivate().privateLoadFromExecutionCache(Fr.fromString(returnsHash));
     return [values.map(toACVMField)];
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_utl_getUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
-    const context = this.handlerAsUtility().getUtilityContext();
+  utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
+    const context = this.handlerAsUtility().utilityGetUtilityContext();
     return Promise.resolve(context.toNoirRepresentation());
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
-    const keyValidationRequest = await this.handlerAsUtility().getKeyValidationRequest(Fr.fromString(pkMHash));
+  async utilityGetKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
+    const keyValidationRequest = await this.handlerAsUtility().utilityGetKeyValidationRequest(Fr.fromString(pkMHash));
 
     return keyValidationRequest.toFields().map(toACVMField);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getContractInstance([address]: ACVMField[]): Promise<ACVMField[]> {
-    const instance = await this.handlerAsUtility().getContractInstance(AztecAddress.fromField(Fr.fromString(address)));
+  async utilityGetContractInstance([address]: ACVMField[]): Promise<ACVMField[]> {
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(
+      AztecAddress.fromField(Fr.fromString(address)),
+    );
 
     return [
       instance.salt,
@@ -142,15 +137,17 @@ export class Oracle {
     ].map(toACVMField);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getNoteHashMembershipWitness(
+  async utilityGetNoteHashMembershipWitness(
     [anchorBlockHash]: ACVMField[],
     [noteHash]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
     const parsedAnchorBlockHash = BlockHash.fromString(anchorBlockHash);
     const parsedNoteHash = Fr.fromString(noteHash);
 
-    const witness = await this.handlerAsUtility().getNoteHashMembershipWitness(parsedAnchorBlockHash, parsedNoteHash);
+    const witness = await this.handlerAsUtility().utilityGetNoteHashMembershipWitness(
+      parsedAnchorBlockHash,
+      parsedNoteHash,
+    );
     if (!witness) {
       throw new Error(
         `Note hash ${noteHash} not found in the note hash tree at anchor block hash ${parsedAnchorBlockHash.toString()}.`,
@@ -159,15 +156,17 @@ export class Oracle {
     return witness.toNoirRepresentation();
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getBlockHashMembershipWitness(
+  async utilityGetBlockHashMembershipWitness(
     [anchorBlockHash]: ACVMField[],
     [blockHash]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
     const parsedAnchorBlockHash = BlockHash.fromString(anchorBlockHash);
     const parsedBlockHash = BlockHash.fromString(blockHash);
 
-    const witness = await this.handlerAsUtility().getBlockHashMembershipWitness(parsedAnchorBlockHash, parsedBlockHash);
+    const witness = await this.handlerAsUtility().utilityGetBlockHashMembershipWitness(
+      parsedAnchorBlockHash,
+      parsedBlockHash,
+    );
     if (!witness) {
       throw new Error(
         `Block hash ${parsedBlockHash.toString()} not found in the archive tree at anchor block ${parsedAnchorBlockHash.toString()}.`,
@@ -176,15 +175,17 @@ export class Oracle {
     return witness.toNoirRepresentation();
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getNullifierMembershipWitness(
+  async utilityGetNullifierMembershipWitness(
     [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the witness for (to prove inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
     const parsedBlockHash = BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
-    const witness = await this.handlerAsUtility().getNullifierMembershipWitness(parsedBlockHash, parsedNullifier);
+    const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(
+      parsedBlockHash,
+      parsedNullifier,
+    );
     if (!witness) {
       throw new Error(
         `Nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
@@ -193,15 +194,17 @@ export class Oracle {
     return witness.toNoirRepresentation();
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getLowNullifierMembershipWitness(
+  async utilityGetLowNullifierMembershipWitness(
     [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the low nullifier witness for (to prove non-inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
     const parsedBlockHash = BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
-    const witness = await this.handlerAsUtility().getLowNullifierMembershipWitness(parsedBlockHash, parsedNullifier);
+    const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(
+      parsedBlockHash,
+      parsedNullifier,
+    );
     if (!witness) {
       throw new Error(
         `Low nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
@@ -210,15 +213,14 @@ export class Oracle {
     return witness.toNoirRepresentation();
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getPublicDataWitness(
+  async utilityGetPublicDataWitness(
     [blockHash]: ACVMField[],
     [leafSlot]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
     const parsedBlockHash = BlockHash.fromString(blockHash);
     const parsedLeafSlot = Fr.fromString(leafSlot);
 
-    const witness = await this.handlerAsUtility().getPublicDataWitness(parsedBlockHash, parsedLeafSlot);
+    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(parsedBlockHash, parsedLeafSlot);
     if (!witness) {
       throw new Error(
         `Public data witness not found for slot ${parsedLeafSlot} at block hash ${parsedBlockHash.toString()}.`,
@@ -227,31 +229,28 @@ export class Oracle {
     return witness.toNoirRepresentation();
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getBlockHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]> {
+  async utilityGetBlockHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]> {
     const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
 
-    const header = await this.handlerAsUtility().getBlockHeader(BlockNumber(parsedBlockNumber));
+    const header = await this.handlerAsUtility().utilityGetBlockHeader(BlockNumber(parsedBlockNumber));
     if (!header) {
       throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
     }
     return header.toFields().map(toACVMField);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[][]> {
+  async utilityGetAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[][]> {
     const messageHashField = Fr.fromString(messageHash);
-    const witness = await this.handlerAsUtility().getAuthWitness(messageHashField);
+    const witness = await this.handlerAsUtility().utilityGetAuthWitness(messageHashField);
     if (!witness) {
       throw new Error(`Unknown auth witness for message hash ${messageHashField}`);
     }
     return [witness.map(toACVMField)];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_tryGetPublicKeysAndPartialAddress([address]: ACVMField[]): Promise<(ACVMField | ACVMField[])[]> {
+  async utilityTryGetPublicKeysAndPartialAddress([address]: ACVMField[]): Promise<(ACVMField | ACVMField[])[]> {
     const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
-    const result = await this.handlerAsUtility().tryGetPublicKeysAndPartialAddress(parsedAddress);
+    const result = await this.handlerAsUtility().utilityTryGetPublicKeysAndPartialAddress(parsedAddress);
 
     // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
     // with two fields: `some` (a boolean) and `value` (a field array in this case).
@@ -264,8 +263,7 @@ export class Oracle {
     }
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getNotes(
+  async utilityGetNotes(
     [ownerSome]: ACVMField[],
     [ownerValue]: ACVMField[],
     [storageSlot]: ACVMField[],
@@ -287,7 +285,7 @@ export class Oracle {
   ): Promise<(ACVMField | ACVMField[])[]> {
     // Parse Option<AztecAddress>: ownerSome is 0 for None, 1 for Some
     const owner = Fr.fromString(ownerSome).toNumber() === 1 ? AztecAddress.fromString(ownerValue) : undefined;
-    const noteDatas = await this.handlerAsUtility().getNotes(
+    const noteDatas = await this.handlerAsUtility().utilityGetNotes(
       owner,
       Fr.fromString(storageSlot),
       +numSelects,
@@ -326,8 +324,7 @@ export class Oracle {
     return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedHintedNoteLength);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_prv_notifyCreatedNote(
+  privateNotifyCreatedNote(
     [owner]: ACVMField[],
     [storageSlot]: ACVMField[],
     [randomness]: ACVMField[],
@@ -336,7 +333,7 @@ export class Oracle {
     [noteHash]: ACVMField[],
     [counter]: ACVMField[],
   ): Promise<ACVMField[]> {
-    this.handlerAsPrivate().notifyCreatedNote(
+    this.handlerAsPrivate().privateNotifyCreatedNote(
       AztecAddress.fromString(owner),
       Fr.fromString(storageSlot),
       Fr.fromString(randomness),
@@ -348,47 +345,43 @@ export class Oracle {
     return Promise.resolve([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifyNullifiedNote(
+  async privateNotifyNullifiedNote(
     [innerNullifier]: ACVMField[],
     [noteHash]: ACVMField[],
     [counter]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().notifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
+    await this.handlerAsPrivate().privateNotifyNullifiedNote(
+      Fr.fromString(innerNullifier),
+      Fr.fromString(noteHash),
+      +counter,
+    );
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifyCreatedNullifier([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().notifyCreatedNullifier(Fr.fromString(innerNullifier));
+  async privateNotifyCreatedNullifier([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
+    await this.handlerAsPrivate().privateNotifyCreatedNullifier(Fr.fromString(innerNullifier));
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_isNullifierPending(
-    [innerNullifier]: ACVMField[],
-    [contractAddress]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    const isPending = await this.handlerAsPrivate().isNullifierPending(
+  async privateIsNullifierPending([innerNullifier]: ACVMField[], [contractAddress]: ACVMField[]): Promise<ACVMField[]> {
+    const isPending = await this.handlerAsPrivate().privateIsNullifierPending(
       Fr.fromString(innerNullifier),
       AztecAddress.fromString(contractAddress),
     );
     return [toACVMField(isPending)];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_checkNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
-    const exists = await this.handlerAsUtility().checkNullifierExists(Fr.fromString(innerNullifier));
+  async utilityCheckNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
+    const exists = await this.handlerAsUtility().utilityCheckNullifierExists(Fr.fromString(innerNullifier));
     return [toACVMField(exists)];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getL1ToL2MembershipWitness(
+  async utilityGetL1ToL2MembershipWitness(
     [contractAddress]: ACVMField[],
     [messageHash]: ACVMField[],
     [secret]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const message = await this.handlerAsUtility().getL1ToL2MembershipWitness(
+    const message = await this.handlerAsUtility().utilityGetL1ToL2MembershipWitness(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(messageHash),
       Fr.fromString(secret),
@@ -396,14 +389,13 @@ export class Oracle {
     return message.toNoirRepresentation();
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_storageRead(
+  async utilityStorageRead(
     [blockHash]: ACVMField[],
     [contractAddress]: ACVMField[],
     [startStorageSlot]: ACVMField[],
     [numberOfElements]: ACVMField[],
   ): Promise<ACVMField[][]> {
-    const values = await this.handlerAsUtility().storageRead(
+    const values = await this.handlerAsUtility().utilityStorageRead(
       BlockHash.fromString(blockHash),
       new AztecAddress(Fr.fromString(contractAddress)),
       Fr.fromString(startStorageSlot),
@@ -412,8 +404,7 @@ export class Oracle {
     return [values.map(toACVMField)];
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_prv_notifyCreatedContractClassLog(
+  privateNotifyCreatedContractClassLog(
     [contractAddress]: ACVMField[],
     message: ACVMField[],
     [length]: ACVMField[],
@@ -422,12 +413,11 @@ export class Oracle {
     const logFields = new ContractClassLogFields(message.map(Fr.fromString));
     const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
 
-    this.handlerAsPrivate().notifyCreatedContractClassLog(log, +counter);
+    this.handlerAsPrivate().privateNotifyCreatedContractClassLog(log, +counter);
     return Promise.resolve([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_log(
+  async utilityLog(
     level: ACVMField[],
     message: ACVMField[],
     _ignoredFieldsSize: ACVMField[],
@@ -436,21 +426,20 @@ export class Oracle {
     const levelFr = Fr.fromString(level[0]);
     const messageStr = message.map(acvmField => String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
     const fieldsFr = fields.map(Fr.fromString);
-    await this.handlerAsMisc().log(levelFr.toNumber(), messageStr, fieldsFr);
+    await this.handlerAsMisc().utilityLog(levelFr.toNumber(), messageStr, fieldsFr);
     return [];
   }
 
   // This function's name is directly hardcoded in `circuit_recorder.ts`. Don't forget to update it there if you
   // change the name here.
-  // eslint-disable-next-line camelcase
-  async aztec_prv_callPrivateFunction(
+  async privateCallPrivateFunction(
     [contractAddress]: ACVMField[],
     [functionSelector]: ACVMField[],
     [argsHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
   ): Promise<ACVMField[][]> {
-    const { endSideEffectCounter, returnsHash } = await this.handlerAsPrivate().callPrivateFunction(
+    const { endSideEffectCounter, returnsHash } = await this.handlerAsPrivate().privateCallPrivateFunction(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       FunctionSelector.fromField(Fr.fromString(functionSelector)),
       Fr.fromString(argsHash),
@@ -460,14 +449,13 @@ export class Oracle {
     return [[endSideEffectCounter, returnsHash].map(toACVMField)];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifyEnqueuedPublicFunctionCall(
+  async privateNotifyEnqueuedPublicFunctionCall(
     [contractAddress]: ACVMField[],
     [calldataHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().notifyEnqueuedPublicFunctionCall(
+    await this.handlerAsPrivate().privateNotifyEnqueuedPublicFunctionCall(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(calldataHash),
       Fr.fromString(sideEffectCounter).toNumber(),
@@ -476,14 +464,13 @@ export class Oracle {
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifySetPublicTeardownFunctionCall(
+  async privateNotifySetPublicTeardownFunctionCall(
     [contractAddress]: ACVMField[],
     [calldataHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().notifySetPublicTeardownFunctionCall(
+    await this.handlerAsPrivate().privateNotifySetPublicTeardownFunctionCall(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(calldataHash),
       Fr.fromString(sideEffectCounter).toNumber(),
@@ -492,46 +479,41 @@ export class Oracle {
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<
+  async privateNotifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<
     ACVMField[]
   > {
-    await this.handlerAsPrivate().notifySetMinRevertibleSideEffectCounter(
+    await this.handlerAsPrivate().privateNotifySetMinRevertibleSideEffectCounter(
       Fr.fromString(minRevertibleSideEffectCounter).toNumber(),
     );
     return Promise.resolve([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_isSideEffectCounterRevertible([sideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
-    const isRevertible = await this.handlerAsPrivate().isSideEffectCounterRevertible(
+  async privateIsSideEffectCounterRevertible([sideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
+    const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(
       Fr.fromString(sideEffectCounter).toNumber(),
     );
     return Promise.resolve([toACVMField(isRevertible)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_getNextAppTagAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
-    const tag = await this.handlerAsPrivate().getNextAppTagAsSender(
+  async privateGetNextAppTagAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
+    const tag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(
       AztecAddress.fromString(sender),
       AztecAddress.fromString(recipient),
     );
     return [toACVMField(tag.value)];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_fetchTaggedLogs([pendingTaggedLogArrayBaseSlot]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsUtility().fetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
+  async utilityFetchTaggedLogs([pendingTaggedLogArrayBaseSlot]: ACVMField[]): Promise<ACVMField[]> {
+    await this.handlerAsUtility().utilityFetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(
+  async utilityValidateAndStoreEnqueuedNotesAndEvents(
     [contractAddress]: ACVMField[],
     [noteValidationRequestsArrayBaseSlot]: ACVMField[],
     [eventValidationRequestsArrayBaseSlot]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
+    await this.handlerAsUtility().utilityValidateAndStoreEnqueuedNotesAndEvents(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(noteValidationRequestsArrayBaseSlot),
       Fr.fromString(eventValidationRequestsArrayBaseSlot),
@@ -540,13 +522,12 @@ export class Oracle {
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_bulkRetrieveLogs(
+  async utilityBulkRetrieveLogs(
     [contractAddress]: ACVMField[],
     [logRetrievalRequestsArrayBaseSlot]: ACVMField[],
     [logRetrievalResponsesArrayBaseSlot]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().bulkRetrieveLogs(
+    await this.handlerAsUtility().utilityBulkRetrieveLogs(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(logRetrievalRequestsArrayBaseSlot),
       Fr.fromString(logRetrievalResponsesArrayBaseSlot),
@@ -554,13 +535,12 @@ export class Oracle {
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_storeCapsule(
+  async utilityStoreCapsule(
     [contractAddress]: ACVMField[],
     [slot]: ACVMField[],
     capsule: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().storeCapsule(
+    await this.handlerAsUtility().utilityStoreCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(slot),
       capsule.map(Fr.fromString),
@@ -568,13 +548,12 @@ export class Oracle {
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_loadCapsule(
+  async utilityLoadCapsule(
     [contractAddress]: ACVMField[],
     [slot]: ACVMField[],
     [tSize]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const values = await this.handlerAsUtility().loadCapsule(
+    const values = await this.handlerAsUtility().utilityLoadCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(slot),
     );
@@ -590,23 +569,21 @@ export class Oracle {
     }
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_deleteCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsUtility().deleteCapsule(
+  async utilityDeleteCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[]): Promise<ACVMField[]> {
+    await this.handlerAsUtility().utilityDeleteCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(slot),
     );
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_copyCapsule(
+  async utilityCopyCapsule(
     [contractAddress]: ACVMField[],
     [srcSlot]: ACVMField[],
     [dstSlot]: ACVMField[],
     [numEntries]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().copyCapsule(
+    await this.handlerAsUtility().utilityCopyCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(srcSlot),
       Fr.fromString(dstSlot),
@@ -615,8 +592,7 @@ export class Oracle {
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_aes128Decrypt(
+  async utilityAes128Decrypt(
     ciphertextBVecStorage: ACVMField[],
     [ciphertextLength]: ACVMField[],
     iv: ACVMField[],
@@ -626,40 +602,36 @@ export class Oracle {
     const ivBuffer = fromUintArray(iv, 8);
     const symKeyBuffer = fromUintArray(symKey, 8);
 
-    const plaintext = await this.handlerAsUtility().aes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
+    const plaintext = await this.handlerAsUtility().utilityAes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
     return bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getSharedSecret(
+  async utilityGetSharedSecret(
     [address]: ACVMField[],
     [ephPKField0]: ACVMField[],
     [ephPKField1]: ACVMField[],
     [ephPKField2]: ACVMField[],
   ): Promise<ACVMField[]> {
-    const secret = await this.handlerAsUtility().getSharedSecret(
+    const secret = await this.handlerAsUtility().utilityGetSharedSecret(
       AztecAddress.fromField(Fr.fromString(address)),
       Point.fromFields([ephPKField0, ephPKField1, ephPKField2].map(Fr.fromString)),
     );
     return secret.toFields().map(toACVMField);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_emitOffchainEffect(data: ACVMField[]) {
-    await this.handlerAsPrivate().emitOffchainEffect(data.map(Fr.fromString));
+  async utilityEmitOffchainEffect(data: ACVMField[]) {
+    await this.handlerAsPrivate().utilityEmitOffchainEffect(data.map(Fr.fromString));
     return [];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_getSenderForTags(): Promise<ACVMField[]> {
-    const sender = await this.handlerAsPrivate().getSenderForTags();
+  async privateGetSenderForTags(): Promise<ACVMField[]> {
+    const sender = await this.handlerAsPrivate().privateGetSenderForTags();
     // Return [1, address] for Some(address), [0, 0] for None
     return sender ? [toACVMField(1n), toACVMField(sender)] : [toACVMField(0n), toACVMField(0n)];
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_setSenderForTags([senderForTags]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().setSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
+  async privateSetSenderForTags([senderForTags]: ACVMField[]): Promise<ACVMField[]> {
+    await this.handlerAsPrivate().privateSetSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
     return [];
   }
 }

package/src/contract_function_simulator/oracle/private_execution.ts

@@ -76,7 +76,7 @@ export async function executePrivateFunction(
 
   const contractClassLogs = privateExecutionOracle.getContractClassLogs();
 
-  const rawReturnValues = await privateExecutionOracle.loadFromExecutionCache(publicInputs.returnsHash);
+  const rawReturnValues = await privateExecutionOracle.privateLoadFromExecutionCache(publicInputs.returnsHash);
 
   const newNotes = privateExecutionOracle.getNewNotes();
   const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();