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

package/src/rpc_translator.ts

@@ -104,15 +104,13 @@ export class RPCTranslator {
 
   // TXE session state transition functions - these get handled by the state handler
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_setTopLevelTXEContext() {
+  async txeSetTopLevelTXEContext() {
     await this.stateHandler.enterTopLevelState();
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_setPrivateTXEContext(
+  async txeSetPrivateTXEContext(
     foreignContractAddressIsSome: ForeignCallSingle,
     foreignContractAddressValue: ForeignCallSingle,
     foreignAnchorBlockNumberIsSome: ForeignCallSingle,
@@ -131,8 +129,7 @@ export class RPCTranslator {
     return toForeignCallResult(privateContextInputs.toFields().map(toSingle));
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_setPublicTXEContext(
+  async txeSetPublicTXEContext(
     foreignContractAddressIsSome: ForeignCallSingle,
     foreignContractAddressValue: ForeignCallSingle,
   ) {
@@ -145,8 +142,7 @@ export class RPCTranslator {
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_setUtilityTXEContext(
+  async txeSetUtilityTXEContext(
     foreignContractAddressIsSome: ForeignCallSingle,
     foreignContractAddressValue: ForeignCallSingle,
   ) {
@@ -163,54 +159,44 @@ export class RPCTranslator {
 
   // TXE-specific oracles
 
-  // eslint-disable-next-line camelcase
-  aztec_txe_getDefaultAddress() {
-    const defaultAddress = this.handlerAsTxe().getDefaultAddress();
+  txeGetDefaultAddress() {
+    const defaultAddress = this.handlerAsTxe().txeGetDefaultAddress();
 
     return toForeignCallResult([toSingle(defaultAddress)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_getNextBlockNumber() {
-    const nextBlockNumber = await this.handlerAsTxe().getNextBlockNumber();
+  async txeGetNextBlockNumber() {
+    const nextBlockNumber = await this.handlerAsTxe().txeGetNextBlockNumber();
 
     return toForeignCallResult([toSingle(nextBlockNumber)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_getNextBlockTimestamp() {
-    const nextBlockTimestamp = await this.handlerAsTxe().getNextBlockTimestamp();
+  async txeGetNextBlockTimestamp() {
+    const nextBlockTimestamp = await this.handlerAsTxe().txeGetNextBlockTimestamp();
 
     return toForeignCallResult([toSingle(nextBlockTimestamp)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_advanceBlocksBy(foreignBlocks: ForeignCallSingle) {
+  async txeAdvanceBlocksBy(foreignBlocks: ForeignCallSingle) {
     const blocks = fromSingle(foreignBlocks).toNumber();
 
-    await this.handlerAsTxe().advanceBlocksBy(blocks);
+    await this.handlerAsTxe().txeAdvanceBlocksBy(blocks);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_txe_advanceTimestampBy(foreignDuration: ForeignCallSingle) {
+  txeAdvanceTimestampBy(foreignDuration: ForeignCallSingle) {
     const duration = fromSingle(foreignDuration).toBigInt();
 
-    this.handlerAsTxe().advanceTimestampBy(duration);
+    this.handlerAsTxe().txeAdvanceTimestampBy(duration);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_deploy(
-    artifact: ContractArtifact,
-    instance: ContractInstanceWithAddress,
-    foreignSecret: ForeignCallSingle,
-  ) {
+  async txeDeploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: ForeignCallSingle) {
     const secret = fromSingle(foreignSecret);
 
-    await this.handlerAsTxe().deploy(artifact, instance, secret);
+    await this.handlerAsTxe().txeDeploy(artifact, instance, secret);
 
     return toForeignCallResult([
       toArray([
@@ -223,11 +209,10 @@ export class RPCTranslator {
     ]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_createAccount(foreignSecret: ForeignCallSingle) {
+  async txeCreateAccount(foreignSecret: ForeignCallSingle) {
     const secret = fromSingle(foreignSecret);
 
-    const completeAddress = await this.handlerAsTxe().createAccount(secret);
+    const completeAddress = await this.handlerAsTxe().txeCreateAccount(secret);
 
     return toForeignCallResult([
       toSingle(completeAddress.address),
@@ -235,15 +220,14 @@ export class RPCTranslator {
     ]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_addAccount(
+  async txeAddAccount(
     artifact: ContractArtifact,
     instance: ContractInstanceWithAddress,
     foreignSecret: ForeignCallSingle,
   ) {
     const secret = fromSingle(foreignSecret);
 
-    const completeAddress = await this.handlerAsTxe().addAccount(artifact, instance, secret);
+    const completeAddress = await this.handlerAsTxe().txeAddAccount(artifact, instance, secret);
 
     return toForeignCallResult([
       toSingle(completeAddress.address),
@@ -251,44 +235,39 @@ export class RPCTranslator {
     ]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_addAuthWitness(foreignAddress: ForeignCallSingle, foreignMessageHash: ForeignCallSingle) {
+  async txeAddAuthWitness(foreignAddress: ForeignCallSingle, foreignMessageHash: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
     const messageHash = fromSingle(foreignMessageHash);
 
-    await this.handlerAsTxe().addAuthWitness(address, messageHash);
+    await this.handlerAsTxe().txeAddAuthWitness(address, messageHash);
 
     return toForeignCallResult([]);
   }
 
   // PXE oracles
 
-  // eslint-disable-next-line camelcase
-  aztec_utl_assertCompatibleOracleVersion(foreignVersion: ForeignCallSingle) {
+  utilityAssertCompatibleOracleVersion(foreignVersion: ForeignCallSingle) {
     const version = fromSingle(foreignVersion).toNumber();
 
-    this.handlerAsMisc().assertCompatibleOracleVersion(version);
+    this.handlerAsMisc().utilityAssertCompatibleOracleVersion(version);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_utl_getRandomField() {
-    const randomField = this.handlerAsMisc().getRandomField();
+  utilityGetRandomField() {
+    const randomField = this.handlerAsMisc().utilityGetRandomField();
 
     return toForeignCallResult([toSingle(randomField)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_getLastBlockTimestamp() {
-    const timestamp = await this.handlerAsTxe().getLastBlockTimestamp();
+  async txeGetLastBlockTimestamp() {
+    const timestamp = await this.handlerAsTxe().txeGetLastBlockTimestamp();
 
     return toForeignCallResult([toSingle(new Fr(timestamp))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_getLastTxEffects() {
-    const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().getLastTxEffects();
+  async txeGetLastTxEffects() {
+    const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().txeGetLastTxEffects();
 
     return toForeignCallResult([
       toSingle(txHash.hash),
@@ -297,8 +276,7 @@ export class RPCTranslator {
     ]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_getPrivateEvents(
+  async txeGetPrivateEvents(
     foreignSelector: ForeignCallSingle,
     foreignContractAddress: ForeignCallSingle,
     foreignScope: ForeignCallSingle,
@@ -314,7 +292,7 @@ export class RPCTranslator {
       await this.stateHandler.cycleJob();
     }
 
-    const events = await this.handlerAsTxe().getPrivateEvents(selector, contractAddress, scope);
+    const events = await this.handlerAsTxe().txeGetPrivateEvents(selector, contractAddress, scope);
 
     if (events.length > MAX_PRIVATE_EVENTS_PER_TXE_QUERY) {
       throw new Error(`Array of length ${events.length} larger than maxLen ${MAX_PRIVATE_EVENTS_PER_TXE_QUERY}`);
@@ -338,29 +316,26 @@ export class RPCTranslator {
     return toForeignCallResult([toArray(rawArrayStorage), toArray(eventLengths), toSingle(queryLength)]);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_prv_storeInExecutionCache(foreignValues: ForeignCallArray, foreignHash: ForeignCallSingle) {
+  privateStoreInExecutionCache(foreignValues: ForeignCallArray, foreignHash: ForeignCallSingle) {
     const values = fromArray(foreignValues);
     const hash = fromSingle(foreignHash);
 
-    this.handlerAsPrivate().storeInExecutionCache(values, hash);
+    this.handlerAsPrivate().privateStoreInExecutionCache(values, hash);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_loadFromExecutionCache(foreignHash: ForeignCallSingle) {
+  async privateLoadFromExecutionCache(foreignHash: ForeignCallSingle) {
     const hash = fromSingle(foreignHash);
 
-    const returns = await this.handlerAsPrivate().loadFromExecutionCache(hash);
+    const returns = await this.handlerAsPrivate().privateLoadFromExecutionCache(hash);
 
     return toForeignCallResult([toArray(returns)]);
   }
 
   // When the argument is a slice, noir automatically adds a length field to oracle call.
   // When the argument is an array, we add the field length manually to the signature.
-  // eslint-disable-next-line camelcase
-  async aztec_utl_log(
+  async utilityLog(
     foreignLevel: ForeignCallSingle,
     foreignMessage: ForeignCallArray,
     _foreignLength: ForeignCallSingle,
@@ -372,13 +347,12 @@ export class RPCTranslator {
       .join('');
     const fields = fromArray(foreignFields);
 
-    await this.handlerAsMisc().log(level, message, fields);
+    await this.handlerAsMisc().utilityLog(level, message, fields);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_storageRead(
+  async utilityStorageRead(
     foreignBlockHash: ForeignCallSingle,
     foreignContractAddress: ForeignCallSingle,
     foreignStartStorageSlot: ForeignCallSingle,
@@ -389,7 +363,7 @@ export class RPCTranslator {
     const startStorageSlot = fromSingle(foreignStartStorageSlot);
     const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
 
-    const values = await this.handlerAsUtility().storageRead(
+    const values = await this.handlerAsUtility().utilityStorageRead(
       blockHash,
       contractAddress,
       startStorageSlot,
@@ -399,12 +373,11 @@ export class RPCTranslator {
     return toForeignCallResult([toArray(values)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getPublicDataWitness(foreignBlockHash: ForeignCallSingle, foreignLeafSlot: ForeignCallSingle) {
+  async utilityGetPublicDataWitness(foreignBlockHash: ForeignCallSingle, foreignLeafSlot: ForeignCallSingle) {
     const blockHash = new BlockHash(fromSingle(foreignBlockHash));
     const leafSlot = fromSingle(foreignLeafSlot);
 
-    const witness = await this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot);
+    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(blockHash, leafSlot);
 
     if (!witness) {
       throw new Error(`Public data witness not found for slot ${leafSlot} at block ${blockHash.toString()}.`);
@@ -412,8 +385,7 @@ export class RPCTranslator {
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getNotes(
+  async utilityGetNotes(
     foreignOwnerIsSome: ForeignCallSingle,
     foreignOwnerValue: ForeignCallSingle,
     foreignStorageSlot: ForeignCallSingle,
@@ -454,7 +426,7 @@ export class RPCTranslator {
     const maxNotes = fromSingle(foreignMaxNotes).toNumber();
     const packedHintedNoteLength = fromSingle(foreignPackedHintedNoteLength).toNumber();
 
-    const noteDatas = await this.handlerAsUtility().getNotes(
+    const noteDatas = await this.handlerAsUtility().utilityGetNotes(
       owner,
       storageSlot,
       numSelects,
@@ -495,8 +467,7 @@ export class RPCTranslator {
     );
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_prv_notifyCreatedNote(
+  privateNotifyCreatedNote(
     foreignOwner: ForeignCallSingle,
     foreignStorageSlot: ForeignCallSingle,
     foreignRandomness: ForeignCallSingle,
@@ -513,13 +484,20 @@ export class RPCTranslator {
     const noteHash = fromSingle(foreignNoteHash);
     const counter = fromSingle(foreignCounter).toNumber();
 
-    this.handlerAsPrivate().notifyCreatedNote(owner, storageSlot, randomness, noteTypeId, note, noteHash, counter);
+    this.handlerAsPrivate().privateNotifyCreatedNote(
+      owner,
+      storageSlot,
+      randomness,
+      noteTypeId,
+      note,
+      noteHash,
+      counter,
+    );
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifyNullifiedNote(
+  async privateNotifyNullifiedNote(
     foreignInnerNullifier: ForeignCallSingle,
     foreignNoteHash: ForeignCallSingle,
     foreignCounter: ForeignCallSingle,
@@ -528,47 +506,40 @@ export class RPCTranslator {
     const noteHash = fromSingle(foreignNoteHash);
     const counter = fromSingle(foreignCounter).toNumber();
 
-    await this.handlerAsPrivate().notifyNullifiedNote(innerNullifier, noteHash, counter);
+    await this.handlerAsPrivate().privateNotifyNullifiedNote(innerNullifier, noteHash, counter);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifyCreatedNullifier(foreignInnerNullifier: ForeignCallSingle) {
+  async privateNotifyCreatedNullifier(foreignInnerNullifier: ForeignCallSingle) {
     const innerNullifier = fromSingle(foreignInnerNullifier);
 
-    await this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier);
+    await this.handlerAsPrivate().privateNotifyCreatedNullifier(innerNullifier);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_isNullifierPending(
-    foreignInnerNullifier: ForeignCallSingle,
-    foreignContractAddress: ForeignCallSingle,
-  ) {
+  async privateIsNullifierPending(foreignInnerNullifier: ForeignCallSingle, foreignContractAddress: ForeignCallSingle) {
     const innerNullifier = fromSingle(foreignInnerNullifier);
     const contractAddress = addressFromSingle(foreignContractAddress);
 
-    const isPending = await this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress);
+    const isPending = await this.handlerAsPrivate().privateIsNullifierPending(innerNullifier, contractAddress);
 
     return toForeignCallResult([toSingle(new Fr(isPending))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_checkNullifierExists(foreignInnerNullifier: ForeignCallSingle) {
+  async utilityCheckNullifierExists(foreignInnerNullifier: ForeignCallSingle) {
     const innerNullifier = fromSingle(foreignInnerNullifier);
 
-    const exists = await this.handlerAsUtility().checkNullifierExists(innerNullifier);
+    const exists = await this.handlerAsUtility().utilityCheckNullifierExists(innerNullifier);
 
     return toForeignCallResult([toSingle(new Fr(exists))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getContractInstance(foreignAddress: ForeignCallSingle) {
+  async utilityGetContractInstance(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.handlerAsUtility().getContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult(
       [
@@ -581,11 +552,10 @@ export class RPCTranslator {
     );
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_tryGetPublicKeysAndPartialAddress(foreignAddress: ForeignCallSingle) {
+  async utilityTryGetPublicKeysAndPartialAddress(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const result = await this.handlerAsUtility().tryGetPublicKeysAndPartialAddress(address);
+    const result = await this.handlerAsUtility().utilityTryGetPublicKeysAndPartialAddress(address);
 
     // 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).
@@ -601,17 +571,15 @@ export class RPCTranslator {
     }
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getKeyValidationRequest(foreignPkMHash: ForeignCallSingle) {
+  async utilityGetKeyValidationRequest(foreignPkMHash: ForeignCallSingle) {
     const pkMHash = fromSingle(foreignPkMHash);
 
-    const keyValidationRequest = await this.handlerAsUtility().getKeyValidationRequest(pkMHash);
+    const keyValidationRequest = await this.handlerAsUtility().utilityGetKeyValidationRequest(pkMHash);
 
     return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_prv_callPrivateFunction(
+  privateCallPrivateFunction(
     _foreignTargetContractAddress: ForeignCallSingle,
     _foreignFunctionSelector: ForeignCallSingle,
     _foreignArgsHash: ForeignCallSingle,
@@ -623,15 +591,11 @@ export class RPCTranslator {
     );
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getNullifierMembershipWitness(
-    foreignBlockHash: ForeignCallSingle,
-    foreignNullifier: ForeignCallSingle,
-  ) {
+  async utilityGetNullifierMembershipWitness(foreignBlockHash: ForeignCallSingle, foreignNullifier: ForeignCallSingle) {
     const blockHash = new BlockHash(fromSingle(foreignBlockHash));
     const nullifier = fromSingle(foreignNullifier);
 
-    const witness = await this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier);
+    const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(blockHash, nullifier);
 
     if (!witness) {
       throw new Error(`Nullifier membership witness not found at block ${blockHash}.`);
@@ -639,11 +603,10 @@ export class RPCTranslator {
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getAuthWitness(foreignMessageHash: ForeignCallSingle) {
+  async utilityGetAuthWitness(foreignMessageHash: ForeignCallSingle) {
     const messageHash = fromSingle(foreignMessageHash);
 
-    const authWitness = await this.handlerAsUtility().getAuthWitness(messageHash);
+    const authWitness = await this.handlerAsUtility().utilityGetAuthWitness(messageHash);
 
     if (!authWitness) {
       throw new Error(`Auth witness not found for message hash ${messageHash}.`);
@@ -651,8 +614,7 @@ export class RPCTranslator {
     return toForeignCallResult([toArray(authWitness)]);
   }
 
-  // eslint-disable-next-line camelcase
-  public aztec_prv_notifyEnqueuedPublicFunctionCall(
+  public privateNotifyEnqueuedPublicFunctionCall(
     _foreignTargetContractAddress: ForeignCallSingle,
     _foreignCalldataHash: ForeignCallSingle,
     _foreignSideEffectCounter: ForeignCallSingle,
@@ -661,8 +623,7 @@ export class RPCTranslator {
     throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
   }
 
-  // eslint-disable-next-line camelcase
-  public aztec_prv_notifySetPublicTeardownFunctionCall(
+  public privateNotifySetPublicTeardownFunctionCall(
     _foreignTargetContractAddress: ForeignCallSingle,
     _foreignCalldataHash: ForeignCallSingle,
     _foreignSideEffectCounter: ForeignCallSingle,
@@ -671,30 +632,26 @@ export class RPCTranslator {
     throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
   }
 
-  // eslint-disable-next-line camelcase
-  public aztec_prv_notifySetMinRevertibleSideEffectCounter(_foreignMinRevertibleSideEffectCounter: ForeignCallSingle) {
+  public privateNotifySetMinRevertibleSideEffectCounter(_foreignMinRevertibleSideEffectCounter: ForeignCallSingle) {
     throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
   }
 
-  // eslint-disable-next-line camelcase
-  public async aztec_prv_isSideEffectCounterRevertible(foreignSideEffectCounter: ForeignCallSingle) {
+  public async privateIsSideEffectCounterRevertible(foreignSideEffectCounter: ForeignCallSingle) {
     const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
-    const isRevertible = await this.handlerAsPrivate().isSideEffectCounterRevertible(sideEffectCounter);
+    const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(sideEffectCounter);
     return toForeignCallResult([toSingle(new Fr(isRevertible))]);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_utl_getUtilityContext() {
-    const context = this.handlerAsUtility().getUtilityContext();
+  utilityGetUtilityContext() {
+    const context = this.handlerAsUtility().utilityGetUtilityContext();
 
     return toForeignCallResult(context.toNoirRepresentation());
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getBlockHeader(foreignBlockNumber: ForeignCallSingle) {
+  async utilityGetBlockHeader(foreignBlockNumber: ForeignCallSingle) {
     const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
 
-    const header = await this.handlerAsUtility().getBlockHeader(blockNumber);
+    const header = await this.handlerAsUtility().utilityGetBlockHeader(blockNumber);
 
     if (!header) {
       throw new Error(`Block header not found for block ${blockNumber}.`);
@@ -702,15 +659,14 @@ export class RPCTranslator {
     return toForeignCallResult(header.toFields().map(toSingle));
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getNoteHashMembershipWitness(
+  async utilityGetNoteHashMembershipWitness(
     foreignAnchorBlockHash: ForeignCallSingle,
     foreignNoteHash: ForeignCallSingle,
   ) {
     const blockHash = new BlockHash(fromSingle(foreignAnchorBlockHash));
     const noteHash = fromSingle(foreignNoteHash);
 
-    const witness = await this.handlerAsUtility().getNoteHashMembershipWitness(blockHash, noteHash);
+    const witness = await this.handlerAsUtility().utilityGetNoteHashMembershipWitness(blockHash, noteHash);
 
     if (!witness) {
       throw new Error(`Note hash ${noteHash} not found in the note hash tree at block ${blockHash.toString()}.`);
@@ -718,15 +674,14 @@ export class RPCTranslator {
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getBlockHashMembershipWitness(
+  async utilityGetBlockHashMembershipWitness(
     foreignAnchorBlockHash: ForeignCallSingle,
     foreignBlockHash: ForeignCallSingle,
   ) {
     const anchorBlockHash = new BlockHash(fromSingle(foreignAnchorBlockHash));
     const blockHash = new BlockHash(fromSingle(foreignBlockHash));
 
-    const witness = await this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash);
+    const witness = await this.handlerAsUtility().utilityGetBlockHashMembershipWitness(anchorBlockHash, blockHash);
 
     if (!witness) {
       throw new Error(
@@ -736,15 +691,14 @@ export class RPCTranslator {
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getLowNullifierMembershipWitness(
+  async utilityGetLowNullifierMembershipWitness(
     foreignBlockHash: ForeignCallSingle,
     foreignNullifier: ForeignCallSingle,
   ) {
     const blockHash = new BlockHash(fromSingle(foreignBlockHash));
     const nullifier = fromSingle(foreignNullifier);
 
-    const witness = await this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier);
+    const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(blockHash, nullifier);
 
     if (!witness) {
       throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockHash}.`);
@@ -752,17 +706,15 @@ export class RPCTranslator {
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_fetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot: ForeignCallSingle) {
+  async utilityFetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot: ForeignCallSingle) {
     const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
 
-    await this.handlerAsUtility().fetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
+    await this.handlerAsUtility().utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  public async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(
+  public async utilityValidateAndStoreEnqueuedNotesAndEvents(
     foreignContractAddress: ForeignCallSingle,
     foreignNoteValidationRequestsArrayBaseSlot: ForeignCallSingle,
     foreignEventValidationRequestsArrayBaseSlot: ForeignCallSingle,
@@ -771,7 +723,7 @@ export class RPCTranslator {
     const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
     const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
 
-    await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
+    await this.handlerAsUtility().utilityValidateAndStoreEnqueuedNotesAndEvents(
       contractAddress,
       noteValidationRequestsArrayBaseSlot,
       eventValidationRequestsArrayBaseSlot,
@@ -780,8 +732,7 @@ export class RPCTranslator {
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  public async aztec_utl_bulkRetrieveLogs(
+  public async utilityBulkRetrieveLogs(
     foreignContractAddress: ForeignCallSingle,
     foreignLogRetrievalRequestsArrayBaseSlot: ForeignCallSingle,
     foreignLogRetrievalResponsesArrayBaseSlot: ForeignCallSingle,
@@ -790,7 +741,7 @@ export class RPCTranslator {
     const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
     const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
 
-    await this.handlerAsUtility().bulkRetrieveLogs(
+    await this.handlerAsUtility().utilityBulkRetrieveLogs(
       contractAddress,
       logRetrievalRequestsArrayBaseSlot,
       logRetrievalResponsesArrayBaseSlot,
@@ -799,8 +750,7 @@ export class RPCTranslator {
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_storeCapsule(
+  async utilityStoreCapsule(
     foreignContractAddress: ForeignCallSingle,
     foreignSlot: ForeignCallSingle,
     foreignCapsule: ForeignCallArray,
@@ -809,13 +759,12 @@ export class RPCTranslator {
     const slot = fromSingle(foreignSlot);
     const capsule = fromArray(foreignCapsule);
 
-    await this.handlerAsUtility().storeCapsule(contractAddress, slot, capsule);
+    await this.handlerAsUtility().utilityStoreCapsule(contractAddress, slot, capsule);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_loadCapsule(
+  async utilityLoadCapsule(
     foreignContractAddress: ForeignCallSingle,
     foreignSlot: ForeignCallSingle,
     foreignTSize: ForeignCallSingle,
@@ -824,7 +773,7 @@ export class RPCTranslator {
     const slot = fromSingle(foreignSlot);
     const tSize = fromSingle(foreignTSize).toNumber();
 
-    const values = await this.handlerAsUtility().loadCapsule(contractAddress, slot);
+    const values = await this.handlerAsUtility().utilityLoadCapsule(contractAddress, slot);
 
     // 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).
@@ -837,18 +786,16 @@ export class RPCTranslator {
     }
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_deleteCapsule(foreignContractAddress: ForeignCallSingle, foreignSlot: ForeignCallSingle) {
+  async utilityDeleteCapsule(foreignContractAddress: ForeignCallSingle, foreignSlot: ForeignCallSingle) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const slot = fromSingle(foreignSlot);
 
-    await this.handlerAsUtility().deleteCapsule(contractAddress, slot);
+    await this.handlerAsUtility().utilityDeleteCapsule(contractAddress, slot);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_copyCapsule(
+  async utilityCopyCapsule(
     foreignContractAddress: ForeignCallSingle,
     foreignSrcSlot: ForeignCallSingle,
     foreignDstSlot: ForeignCallSingle,
@@ -859,7 +806,7 @@ export class RPCTranslator {
     const dstSlot = fromSingle(foreignDstSlot);
     const numEntries = fromSingle(foreignNumEntries).toNumber();
 
-    await this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+    await this.handlerAsUtility().utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
 
     return toForeignCallResult([]);
   }
@@ -868,8 +815,7 @@ export class RPCTranslator {
   // The compiler didn't throw an error, so it took me a while to learn of the existence of this file, and that I need
   // to implement this function here. Isn't there a way to programmatically identify that this is missing, given the
   // existence of a txe_oracle method?
-  // eslint-disable-next-line camelcase
-  async aztec_utl_aes128Decrypt(
+  async utilityAes128Decrypt(
     foreignCiphertextBVecStorage: ForeignCallArray,
     foreignCiphertextLength: ForeignCallSingle,
     foreignIv: ForeignCallArray,
@@ -879,15 +825,14 @@ export class RPCTranslator {
     const iv = fromUintArray(foreignIv, 8);
     const symKey = fromUintArray(foreignSymKey, 8);
 
-    const plaintextBuffer = await this.handlerAsUtility().aes128Decrypt(ciphertext, iv, symKey);
+    const plaintextBuffer = await this.handlerAsUtility().utilityAes128Decrypt(ciphertext, iv, symKey);
 
     return toForeignCallResult(
       arrayToBoundedVec(bufferToU8Array(plaintextBuffer), foreignCiphertextBVecStorage.length),
     );
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getSharedSecret(
+  async utilityGetSharedSecret(
     foreignAddress: ForeignCallSingle,
     foreignEphPKField0: ForeignCallSingle,
     foreignEphPKField1: ForeignCallSingle,
@@ -900,49 +845,44 @@ export class RPCTranslator {
       fromSingle(foreignEphPKField2),
     ]);
 
-    const secret = await this.handlerAsUtility().getSharedSecret(address, ephPK);
+    const secret = await this.handlerAsUtility().utilityGetSharedSecret(address, ephPK);
 
     return toForeignCallResult(secret.toFields().map(toSingle));
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_utl_emitOffchainEffect(_foreignData: ForeignCallArray) {
+  emitOffchainEffect(_foreignData: ForeignCallArray) {
     throw new Error('Offchain effects are not yet supported in the TestEnvironment');
   }
 
   // AVM opcodes
 
-  // eslint-disable-next-line camelcase
-  aztec_avm_emitPublicLog(_foreignMessage: ForeignCallArray) {
+  avmOpcodeEmitPublicLog(_foreignMessage: ForeignCallArray) {
     // TODO(#8811): Implement
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_storageRead(foreignSlot: ForeignCallSingle, foreignContractAddress: ForeignCallSingle) {
+  async avmOpcodeStorageRead(foreignSlot: ForeignCallSingle, foreignContractAddress: ForeignCallSingle) {
     const slot = fromSingle(foreignSlot);
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
 
-    const value = (await this.handlerAsAvm().storageRead(slot, contractAddress)).value;
+    const value = (await this.handlerAsAvm().avmOpcodeStorageRead(slot, contractAddress)).value;
 
     return toForeignCallResult([toSingle(new Fr(value))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_storageWrite(foreignSlot: ForeignCallSingle, foreignValue: ForeignCallSingle) {
+  async avmOpcodeStorageWrite(foreignSlot: ForeignCallSingle, foreignValue: ForeignCallSingle) {
     const slot = fromSingle(foreignSlot);
     const value = fromSingle(foreignValue);
 
-    await this.handlerAsAvm().storageWrite(slot, value);
+    await this.handlerAsAvm().avmOpcodeStorageWrite(slot, value);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_getContractInstanceDeployer(foreignAddress: ForeignCallSingle) {
+  async avmOpcodeGetContractInstanceDeployer(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.handlerAsUtility().getContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult([
       toSingle(instance.deployer),
@@ -951,11 +891,10 @@ export class RPCTranslator {
     ]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_getContractInstanceClassId(foreignAddress: ForeignCallSingle) {
+  async avmOpcodeGetContractInstanceClassId(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.handlerAsUtility().getContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult([
       toSingle(instance.currentContractClassId),
@@ -964,11 +903,10 @@ export class RPCTranslator {
     ]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_getContractInstanceInitializationHash(foreignAddress: ForeignCallSingle) {
+  async avmOpcodeGetContractInstanceInitializationHash(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.handlerAsUtility().getContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult([
       toSingle(instance.initializationHash),
@@ -977,98 +915,85 @@ export class RPCTranslator {
     ]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_sender() {
-    const sender = await this.handlerAsAvm().sender();
+  async avmOpcodeSender() {
+    const sender = await this.handlerAsAvm().avmOpcodeSender();
 
     return toForeignCallResult([toSingle(sender)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_emitNullifier(foreignNullifier: ForeignCallSingle) {
+  async avmOpcodeEmitNullifier(foreignNullifier: ForeignCallSingle) {
     const nullifier = fromSingle(foreignNullifier);
 
-    await this.handlerAsAvm().emitNullifier(nullifier);
+    await this.handlerAsAvm().avmOpcodeEmitNullifier(nullifier);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_emitNoteHash(foreignNoteHash: ForeignCallSingle) {
+  async avmOpcodeEmitNoteHash(foreignNoteHash: ForeignCallSingle) {
     const noteHash = fromSingle(foreignNoteHash);
 
-    await this.handlerAsAvm().emitNoteHash(noteHash);
+    await this.handlerAsAvm().avmOpcodeEmitNoteHash(noteHash);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_nullifierExists(foreignSiloedNullifier: ForeignCallSingle) {
+  async avmOpcodeNullifierExists(foreignSiloedNullifier: ForeignCallSingle) {
     const siloedNullifier = fromSingle(foreignSiloedNullifier);
 
-    const exists = await this.handlerAsAvm().nullifierExists(siloedNullifier);
+    const exists = await this.handlerAsAvm().avmOpcodeNullifierExists(siloedNullifier);
 
     return toForeignCallResult([toSingle(new Fr(exists))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_address() {
-    const contractAddress = await this.handlerAsAvm().address();
+  async avmOpcodeAddress() {
+    const contractAddress = await this.handlerAsAvm().avmOpcodeAddress();
 
     return toForeignCallResult([toSingle(contractAddress.toField())]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_blockNumber() {
-    const blockNumber = await this.handlerAsAvm().blockNumber();
+  async avmOpcodeBlockNumber() {
+    const blockNumber = await this.handlerAsAvm().avmOpcodeBlockNumber();
 
     return toForeignCallResult([toSingle(new Fr(blockNumber))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_timestamp() {
-    const timestamp = await this.handlerAsAvm().timestamp();
+  async avmOpcodeTimestamp() {
+    const timestamp = await this.handlerAsAvm().avmOpcodeTimestamp();
 
     return toForeignCallResult([toSingle(new Fr(timestamp))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_isStaticCall() {
-    const isStaticCall = await this.handlerAsAvm().isStaticCall();
+  async avmOpcodeIsStaticCall() {
+    const isStaticCall = await this.handlerAsAvm().avmOpcodeIsStaticCall();
 
     return toForeignCallResult([toSingle(new Fr(isStaticCall ? 1 : 0))]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_chainId() {
-    const chainId = await this.handlerAsAvm().chainId();
+  async avmOpcodeChainId() {
+    const chainId = await this.handlerAsAvm().avmOpcodeChainId();
 
     return toForeignCallResult([toSingle(chainId)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_avm_version() {
-    const version = await this.handlerAsAvm().version();
+  async avmOpcodeVersion() {
+    const version = await this.handlerAsAvm().avmOpcodeVersion();
 
     return toForeignCallResult([toSingle(version)]);
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_avm_returndataSize() {
+  avmOpcodeReturndataSize() {
     throw new Error(
       'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
     );
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_avm_returndataCopy(_foreignRdOffset: ForeignCallSingle, _foreignCopySize: ForeignCallSingle) {
+  avmOpcodeReturndataCopy(_foreignRdOffset: ForeignCallSingle, _foreignCopySize: ForeignCallSingle) {
     throw new Error(
       'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
     );
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_avm_call(
+  avmOpcodeCall(
     _foreignL2Gas: ForeignCallSingle,
     _foreignDaGas: ForeignCallSingle,
     _foreignAddress: ForeignCallSingle,
@@ -1080,8 +1005,7 @@ export class RPCTranslator {
     );
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_avm_staticCall(
+  avmOpcodeStaticCall(
     _foreignL2Gas: ForeignCallSingle,
     _foreignDaGas: ForeignCallSingle,
     _foreignAddress: ForeignCallSingle,
@@ -1093,15 +1017,13 @@ export class RPCTranslator {
     );
   }
 
-  // eslint-disable-next-line camelcase
-  aztec_avm_successCopy() {
+  avmOpcodeSuccessCopy() {
     throw new Error(
       'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
     );
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_privateCallNewFlow(
+  async txePrivateCallNewFlow(
     foreignFrom: ForeignCallSingle,
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
@@ -1116,7 +1038,7 @@ export class RPCTranslator {
     const argsHash = fromSingle(foreignArgsHash);
     const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
 
-    const returnValues = await this.handlerAsTxe().privateCallNewFlow(
+    const returnValues = await this.handlerAsTxe().txePrivateCallNewFlow(
       from,
       targetContractAddress,
       functionSelector,
@@ -1131,8 +1053,7 @@ export class RPCTranslator {
     return toForeignCallResult([toArray(returnValues)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_executeUtilityFunction(
+  async txeExecuteUtilityFunction(
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
     foreignArgs: ForeignCallArray,
@@ -1141,7 +1062,7 @@ export class RPCTranslator {
     const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
     const args = fromArray(foreignArgs);
 
-    const returnValues = await this.handlerAsTxe().executeUtilityFunction(
+    const returnValues = await this.handlerAsTxe().txeExecuteUtilityFunction(
       targetContractAddress,
       functionSelector,
       args,
@@ -1153,8 +1074,7 @@ export class RPCTranslator {
     return toForeignCallResult([toArray(returnValues)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_txe_publicCallNewFlow(
+  async txePublicCallNewFlow(
     foreignFrom: ForeignCallSingle,
     foreignAddress: ForeignCallSingle,
     foreignCalldata: ForeignCallArray,
@@ -1165,16 +1085,15 @@ export class RPCTranslator {
     const calldata = fromArray(foreignCalldata);
     const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
 
-    const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall);
+    const returnValues = await this.handlerAsTxe().txePublicCallNewFlow(from, address, calldata, isStaticCall);
 
     // TODO(F-335): Avoid doing the following call here.
     await this.stateHandler.cycleJob();
     return toForeignCallResult([toArray(returnValues)]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_getSenderForTags() {
-    const sender = await this.handlerAsPrivate().getSenderForTags();
+  async privateGetSenderForTags() {
+    const sender = await this.handlerAsPrivate().privateGetSenderForTags();
 
     // Return a Noir Option struct with `some` and `value` fields
     if (sender === undefined) {
@@ -1186,21 +1105,19 @@ export class RPCTranslator {
     }
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_setSenderForTags(foreignSenderForTags: ForeignCallSingle) {
+  async privateSetSenderForTags(foreignSenderForTags: ForeignCallSingle) {
     const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
 
-    await this.handlerAsPrivate().setSenderForTags(senderForTags);
+    await this.handlerAsPrivate().privateSetSenderForTags(senderForTags);
 
     return toForeignCallResult([]);
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_getNextAppTagAsSender(foreignSender: ForeignCallSingle, foreignRecipient: ForeignCallSingle) {
+  async privateGetNextAppTagAsSender(foreignSender: ForeignCallSingle, foreignRecipient: ForeignCallSingle) {
     const sender = AztecAddress.fromField(fromSingle(foreignSender));
     const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
 
-    const nextAppTag = await this.handlerAsPrivate().getNextAppTagAsSender(sender, recipient);
+    const nextAppTag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(sender, recipient);
 
     return toForeignCallResult([toSingle(nextAppTag.value)]);
   }