@aztec/txe 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/dest/rpc_translator.js

@@ -1,10 +1,12 @@
 import { Fr, Point } from '@aztec/aztec.js/fields';
 import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
-import { packAsRetrievedNote } from '@aztec/pxe/simulator';
-import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { packAsHintedNote } from '@aztec/pxe/simulator';
+import { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } from './util/encoding.js';
+import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, blockHashFromSingle, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } from './util/encoding.js';
+const MAX_EVENT_LEN = 10; // This is MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN
+const MAX_PRIVATE_EVENTS_PER_TXE_QUERY = 5;
 export class UnavailableOracleError extends Error {
     constructor(oracleName){
         super(`${oracleName} oracles not available with the current handler`);
@@ -58,53 +60,69 @@ export class RPCTranslator {
         return this.oracleHandler;
     }
     // TXE session state transition functions - these get handled by the state handler
-    async txeSetTopLevelTXEContext() {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_setTopLevelTXEContext() {
         await this.stateHandler.enterTopLevelState();
         return toForeignCallResult([]);
     }
-    async txeSetPrivateTXEContext(foreignContractAddressIsSome, foreignContractAddressValue, foreignAnchorBlockNumberIsSome, foreignAnchorBlockNumberValue) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_setPrivateTXEContext(foreignContractAddressIsSome, foreignContractAddressValue, foreignAnchorBlockNumberIsSome, foreignAnchorBlockNumberValue) {
         const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
-        const anchorBlockNumber = fromSingle(foreignAnchorBlockNumberIsSome).toBool() ? fromSingle(foreignAnchorBlockNumberValue).toNumber() : undefined;
+        const anchorBlockNumber = fromSingle(foreignAnchorBlockNumberIsSome).toBool() ? BlockNumber(fromSingle(foreignAnchorBlockNumberValue).toNumber()) : undefined;
         const privateContextInputs = await this.stateHandler.enterPrivateState(contractAddress, anchorBlockNumber);
         return toForeignCallResult(privateContextInputs.toFields().map(toSingle));
     }
-    async txeSetPublicTXEContext(foreignContractAddressIsSome, foreignContractAddressValue) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_setPublicTXEContext(foreignContractAddressIsSome, foreignContractAddressValue) {
         const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
         await this.stateHandler.enterPublicState(contractAddress);
         return toForeignCallResult([]);
     }
-    async txeSetUtilityTXEContext(foreignContractAddressIsSome, foreignContractAddressValue) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_setUtilityTXEContext(foreignContractAddressIsSome, foreignContractAddressValue) {
         const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
         await this.stateHandler.enterUtilityState(contractAddress);
         return toForeignCallResult([]);
     }
     // Other oracles - these get handled by the oracle handler
     // TXE-specific oracles
-    async txeGetNextBlockNumber() {
-        const nextBlockNumber = await this.handlerAsTxe().txeGetNextBlockNumber();
+    // eslint-disable-next-line camelcase
+    aztec_txe_getDefaultAddress() {
+        const defaultAddress = this.handlerAsTxe().getDefaultAddress();
+        return toForeignCallResult([
+            toSingle(defaultAddress)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_txe_getNextBlockNumber() {
+        const nextBlockNumber = await this.handlerAsTxe().getNextBlockNumber();
         return toForeignCallResult([
             toSingle(nextBlockNumber)
         ]);
     }
-    async txeGetNextBlockTimestamp() {
-        const nextBlockTimestamp = await this.handlerAsTxe().txeGetNextBlockTimestamp();
+    // eslint-disable-next-line camelcase
+    async aztec_txe_getNextBlockTimestamp() {
+        const nextBlockTimestamp = await this.handlerAsTxe().getNextBlockTimestamp();
         return toForeignCallResult([
             toSingle(nextBlockTimestamp)
         ]);
     }
-    async txeAdvanceBlocksBy(foreignBlocks) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_advanceBlocksBy(foreignBlocks) {
         const blocks = fromSingle(foreignBlocks).toNumber();
-        await this.handlerAsTxe().txeAdvanceBlocksBy(blocks);
+        await this.handlerAsTxe().advanceBlocksBy(blocks);
         return toForeignCallResult([]);
     }
-    txeAdvanceTimestampBy(foreignDuration) {
+    // eslint-disable-next-line camelcase
+    aztec_txe_advanceTimestampBy(foreignDuration) {
         const duration = fromSingle(foreignDuration).toBigInt();
-        this.handlerAsTxe().txeAdvanceTimestampBy(duration);
+        this.handlerAsTxe().advanceTimestampBy(duration);
         return toForeignCallResult([]);
     }
-    async txeDeploy(artifact, instance, foreignSecret) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_deploy(artifact, instance, foreignSecret) {
         const secret = fromSingle(foreignSecret);
-        await this.handlerAsTxe().txeDeploy(artifact, instance, secret);
+        await this.handlerAsTxe().deploy(artifact, instance, secret);
         return toForeignCallResult([
             toArray([
                 instance.salt,
@@ -115,96 +133,141 @@ export class RPCTranslator {
             ])
         ]);
     }
-    async txeCreateAccount(foreignSecret) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_createAccount(foreignSecret) {
         const secret = fromSingle(foreignSecret);
-        const completeAddress = await this.handlerAsTxe().txeCreateAccount(secret);
+        const completeAddress = await this.handlerAsTxe().createAccount(secret);
         return toForeignCallResult([
             toSingle(completeAddress.address),
             ...completeAddress.publicKeys.toFields().map(toSingle)
         ]);
     }
-    async txeAddAccount(artifact, instance, foreignSecret) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_addAccount(artifact, instance, foreignSecret) {
         const secret = fromSingle(foreignSecret);
-        const completeAddress = await this.handlerAsTxe().txeAddAccount(artifact, instance, secret);
+        const completeAddress = await this.handlerAsTxe().addAccount(artifact, instance, secret);
         return toForeignCallResult([
             toSingle(completeAddress.address),
             ...completeAddress.publicKeys.toFields().map(toSingle)
         ]);
     }
-    async txeAddAuthWitness(foreignAddress, foreignMessageHash) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_addAuthWitness(foreignAddress, foreignMessageHash) {
         const address = addressFromSingle(foreignAddress);
         const messageHash = fromSingle(foreignMessageHash);
-        await this.handlerAsTxe().txeAddAuthWitness(address, messageHash);
+        await this.handlerAsTxe().addAuthWitness(address, messageHash);
         return toForeignCallResult([]);
     }
     // PXE oracles
-    utilityAssertCompatibleOracleVersion(foreignVersion) {
-        const version = fromSingle(foreignVersion).toNumber();
-        this.handlerAsMisc().utilityAssertCompatibleOracleVersion(version);
+    // eslint-disable-next-line camelcase
+    aztec_utl_assertCompatibleOracleVersionV2(foreignMajor, foreignMinor) {
+        const major = fromSingle(foreignMajor).toNumber();
+        const minor = fromSingle(foreignMinor).toNumber();
+        this.handlerAsMisc().assertCompatibleOracleVersion(major, minor);
         return toForeignCallResult([]);
     }
-    utilityGetRandomField() {
-        const randomField = this.handlerAsMisc().utilityGetRandomField();
+    // eslint-disable-next-line camelcase
+    aztec_utl_getRandomField() {
+        const randomField = this.handlerAsMisc().getRandomField();
         return toForeignCallResult([
             toSingle(randomField)
         ]);
     }
-    async txeGetLastBlockTimestamp() {
-        const timestamp = await this.handlerAsTxe().txeGetLastBlockTimestamp();
+    // eslint-disable-next-line camelcase
+    async aztec_txe_getLastBlockTimestamp() {
+        const timestamp = await this.handlerAsTxe().getLastBlockTimestamp();
         return toForeignCallResult([
             toSingle(new Fr(timestamp))
         ]);
     }
-    async txeGetLastTxEffects() {
-        const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().txeGetLastTxEffects();
+    // eslint-disable-next-line camelcase
+    async aztec_txe_getLastTxEffects() {
+        const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().getLastTxEffects();
         return toForeignCallResult([
             toSingle(txHash.hash),
             ...arrayToBoundedVec(toArray(noteHashes), MAX_NOTE_HASHES_PER_TX),
             ...arrayToBoundedVec(toArray(nullifiers), MAX_NULLIFIERS_PER_TX)
         ]);
     }
-    privateStoreInExecutionCache(foreignValues, foreignHash) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_getPrivateEvents(foreignSelector, foreignContractAddress, foreignScope) {
+        const selector = EventSelector.fromField(fromSingle(foreignSelector));
+        const contractAddress = addressFromSingle(foreignContractAddress);
+        const scope = addressFromSingle(foreignScope);
+        // TODO(F-335): Avoid doing the following 2 calls here.
+        {
+            await this.handlerAsTxe().syncContractNonOracleMethod(contractAddress, scope, this.stateHandler.getCurrentJob());
+            // We cycle job to commit the stores after the contract sync.
+            await this.stateHandler.cycleJob();
+        }
+        const events = await this.handlerAsTxe().getPrivateEvents(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}`);
+        }
+        if (events.some((e)=>e.length > MAX_EVENT_LEN)) {
+            throw new Error(`Some private event has length larger than maxLen ${MAX_EVENT_LEN}`);
+        }
+        // This is a workaround as Noir does not currently let us return nested structs with arrays. We instead return a raw
+        // multidimensional array in get_private_events_oracle and create the BoundedVecs here.
+        const rawArrayStorage = events.map((e)=>e.concat(Array(MAX_EVENT_LEN - e.length).fill(new Fr(0)))).concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(Array(MAX_EVENT_LEN).fill(new Fr(0)))).flat();
+        const eventLengths = events.map((e)=>new Fr(e.length)).concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(new Fr(0)));
+        const queryLength = new Fr(events.length);
+        return toForeignCallResult([
+            toArray(rawArrayStorage),
+            toArray(eventLengths),
+            toSingle(queryLength)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_setHashPreimage(foreignValues, foreignHash) {
         const values = fromArray(foreignValues);
         const hash = fromSingle(foreignHash);
-        this.handlerAsPrivate().privateStoreInExecutionCache(values, hash);
+        this.handlerAsPrivate().setHashPreimage(values, hash);
         return toForeignCallResult([]);
     }
-    async privateLoadFromExecutionCache(foreignHash) {
+    // eslint-disable-next-line camelcase
+    async aztec_prv_getHashPreimage(foreignHash) {
         const hash = fromSingle(foreignHash);
-        const returns = await this.handlerAsPrivate().privateLoadFromExecutionCache(hash);
+        const returns = await this.handlerAsPrivate().getHashPreimage(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.
-    utilityDebugLog(foreignLevel, foreignMessage, _foreignLength, foreignFields) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_log(foreignLevel, foreignMessage, _foreignLength, foreignFields) {
         const level = fromSingle(foreignLevel).toNumber();
         const message = fromArray(foreignMessage).map((field)=>String.fromCharCode(field.toNumber())).join('');
         const fields = fromArray(foreignFields);
-        this.handlerAsMisc().utilityDebugLog(level, message, fields);
+        await this.handlerAsMisc().log(level, message, fields);
         return toForeignCallResult([]);
     }
-    async utilityStorageRead(foreignContractAddress, foreignStartStorageSlot, foreignBlockNumber, foreignNumberOfElements) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getFromPublicStorage(foreignBlockHash, foreignContractAddress, foreignStartStorageSlot, foreignNumberOfElements) {
+        const blockHash = blockHashFromSingle(foreignBlockHash);
         const contractAddress = addressFromSingle(foreignContractAddress);
         const startStorageSlot = fromSingle(foreignStartStorageSlot);
-        const blockNumber = fromSingle(foreignBlockNumber).toNumber();
         const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
-        const values = await this.handlerAsUtility().utilityStorageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements);
+        const values = await this.handlerAsUtility().getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements);
         return toForeignCallResult([
             toArray(values)
         ]);
     }
-    async utilityGetPublicDataWitness(foreignBlockNumber, foreignLeafSlot) {
-        const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getPublicDataWitness(foreignBlockHash, foreignLeafSlot) {
+        const blockHash = blockHashFromSingle(foreignBlockHash);
         const leafSlot = fromSingle(foreignLeafSlot);
-        const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(blockNumber, leafSlot);
+        const witness = await this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot);
         if (!witness) {
-            throw new Error(`Public data witness not found for slot ${leafSlot} at block ${blockNumber}.`);
+            throw new Error(`Public data witness not found for slot ${leafSlot} at block ${blockHash.toString()}.`);
         }
         return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async utilityGetNotes(foreignStorageSlot, foreignNumSelects, foreignSelectByIndexes, foreignSelectByOffsets, foreignSelectByLengths, foreignSelectValues, foreignSelectComparators, foreignSortByIndexes, foreignSortByOffsets, foreignSortByLengths, foreignSortOrder, foreignLimit, foreignOffset, foreignStatus, foreignMaxNotes, foreignPackedRetrievedNoteLength) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getNotes(foreignOwnerIsSome, foreignOwnerValue, foreignStorageSlot, foreignNumSelects, foreignSelectByIndexes, foreignSelectByOffsets, foreignSelectByLengths, foreignSelectValues, foreignSelectComparators, foreignSortByIndexes, foreignSortByOffsets, foreignSortByLengths, foreignSortOrder, foreignLimit, foreignOffset, foreignStatus, foreignMaxNotes, foreignPackedHintedNoteLength) {
+        // Parse Option<AztecAddress>: ownerIsSome is 0 for None, 1 for Some
+        const owner = fromSingle(foreignOwnerIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignOwnerValue)) : undefined;
         const storageSlot = fromSingle(foreignStorageSlot);
         const numSelects = fromSingle(foreignNumSelects).toNumber();
         const selectByIndexes = fromArray(foreignSelectByIndexes).map((fr)=>fr.toNumber());
@@ -220,46 +283,69 @@ export class RPCTranslator {
         const offset = fromSingle(foreignOffset).toNumber();
         const status = fromSingle(foreignStatus).toNumber();
         const maxNotes = fromSingle(foreignMaxNotes).toNumber();
-        const packedRetrievedNoteLength = fromSingle(foreignPackedRetrievedNoteLength).toNumber();
-        const noteDatas = await this.handlerAsUtility().utilityGetNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status);
-        const returnDataAsArrayOfArrays = noteDatas.map(packAsRetrievedNote);
+        const packedHintedNoteLength = fromSingle(foreignPackedHintedNoteLength).toNumber();
+        const noteDatas = await this.handlerAsUtility().getNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status);
+        const returnDataAsArrayOfArrays = noteDatas.map((noteData)=>packAsHintedNote({
+                contractAddress: noteData.contractAddress,
+                owner: noteData.owner,
+                randomness: noteData.randomness,
+                storageSlot: noteData.storageSlot,
+                noteNonce: noteData.noteNonce,
+                isPending: noteData.isPending,
+                note: noteData.note
+            }));
         // Now we convert each sub-array to an array of ForeignCallSingles
         const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map((subArray)=>subArray.map(toSingle));
         // At last we convert the array of arrays to a bounded vec of arrays
-        return toForeignCallResult(arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfForeignCallSingleArrays, maxNotes, packedRetrievedNoteLength));
+        return toForeignCallResult(arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfForeignCallSingleArrays, maxNotes, packedHintedNoteLength));
     }
-    privateNotifyCreatedNote(foreignStorageSlot, foreignRandomness, foreignNoteTypeId, foreignNote, foreignNoteHash, foreignCounter) {
+    // eslint-disable-next-line camelcase
+    aztec_prv_notifyCreatedNote(foreignOwner, foreignStorageSlot, foreignRandomness, foreignNoteTypeId, foreignNote, foreignNoteHash, foreignCounter) {
+        const owner = addressFromSingle(foreignOwner);
         const storageSlot = fromSingle(foreignStorageSlot);
         const randomness = fromSingle(foreignRandomness);
         const noteTypeId = NoteSelector.fromField(fromSingle(foreignNoteTypeId));
         const note = fromArray(foreignNote);
         const noteHash = fromSingle(foreignNoteHash);
         const counter = fromSingle(foreignCounter).toNumber();
-        this.handlerAsPrivate().privateNotifyCreatedNote(storageSlot, randomness, noteTypeId, note, noteHash, counter);
+        this.handlerAsPrivate().notifyCreatedNote(owner, storageSlot, randomness, noteTypeId, note, noteHash, counter);
         return toForeignCallResult([]);
     }
-    async privateNotifyNullifiedNote(foreignInnerNullifier, foreignNoteHash, foreignCounter) {
+    // eslint-disable-next-line camelcase
+    async aztec_prv_notifyNullifiedNote(foreignInnerNullifier, foreignNoteHash, foreignCounter) {
         const innerNullifier = fromSingle(foreignInnerNullifier);
         const noteHash = fromSingle(foreignNoteHash);
         const counter = fromSingle(foreignCounter).toNumber();
-        await this.handlerAsPrivate().privateNotifyNullifiedNote(innerNullifier, noteHash, counter);
+        await this.handlerAsPrivate().notifyNullifiedNote(innerNullifier, noteHash, counter);
         return toForeignCallResult([]);
     }
-    async privateNotifyCreatedNullifier(foreignInnerNullifier) {
+    // eslint-disable-next-line camelcase
+    async aztec_prv_notifyCreatedNullifier(foreignInnerNullifier) {
         const innerNullifier = fromSingle(foreignInnerNullifier);
-        await this.handlerAsPrivate().privateNotifyCreatedNullifier(innerNullifier);
+        await this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier);
         return toForeignCallResult([]);
     }
-    async utilityCheckNullifierExists(foreignInnerNullifier) {
+    // eslint-disable-next-line camelcase
+    async aztec_prv_isNullifierPending(foreignInnerNullifier, foreignContractAddress) {
+        const innerNullifier = fromSingle(foreignInnerNullifier);
+        const contractAddress = addressFromSingle(foreignContractAddress);
+        const isPending = await this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress);
+        return toForeignCallResult([
+            toSingle(new Fr(isPending))
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_utl_doesNullifierExist(foreignInnerNullifier) {
         const innerNullifier = fromSingle(foreignInnerNullifier);
-        const exists = await this.handlerAsUtility().utilityCheckNullifierExists(innerNullifier);
+        const exists = await this.handlerAsUtility().doesNullifierExist(innerNullifier);
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
-    async utilityGetContractInstance(foreignAddress) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getContractInstance(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
+        const instance = await this.handlerAsUtility().getContractInstance(address);
         return toForeignCallResult([
             instance.salt,
             instance.deployer.toField(),
@@ -268,36 +354,53 @@ export class RPCTranslator {
             ...instance.publicKeys.toFields()
         ].map(toSingle));
     }
-    async utilityGetPublicKeysAndPartialAddress(foreignAddress) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getPublicKeysAndPartialAddress(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const { publicKeys, partialAddress } = await this.handlerAsUtility().utilityGetPublicKeysAndPartialAddress(address);
-        return toForeignCallResult([
-            toArray([
-                ...publicKeys.toFields(),
-                partialAddress
-            ])
-        ]);
+        const result = await this.handlerAsUtility().getPublicKeysAndPartialAddress(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).
+        if (result === undefined) {
+            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
+            return toForeignCallResult([
+                toSingle(new Fr(0)),
+                toArray(Array(13).fill(new Fr(0)))
+            ]);
+        } else {
+            // Data was found so we set `some` to 1 and return it along with `value`.
+            return toForeignCallResult([
+                toSingle(new Fr(1)),
+                toArray([
+                    ...result.publicKeys.toFields(),
+                    result.partialAddress
+                ])
+            ]);
+        }
     }
-    async utilityGetKeyValidationRequest(foreignPkMHash) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getKeyValidationRequest(foreignPkMHash) {
         const pkMHash = fromSingle(foreignPkMHash);
-        const keyValidationRequest = await this.handlerAsUtility().utilityGetKeyValidationRequest(pkMHash);
+        const keyValidationRequest = await this.handlerAsUtility().getKeyValidationRequest(pkMHash);
         return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
     }
-    privateCallPrivateFunction(_foreignTargetContractAddress, _foreignFunctionSelector, _foreignArgsHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
+    // eslint-disable-next-line camelcase
+    aztec_prv_callPrivateFunction(_foreignTargetContractAddress, _foreignFunctionSelector, _foreignArgsHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
         throw new Error('Contract calls are forbidden inside a `TestEnvironment::private_context`, use `private_call` instead');
     }
-    async utilityGetNullifierMembershipWitness(foreignBlockNumber, foreignNullifier) {
-        const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
+        const blockHash = blockHashFromSingle(foreignBlockHash);
         const nullifier = fromSingle(foreignNullifier);
-        const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(blockNumber, nullifier);
+        const witness = await this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier);
         if (!witness) {
-            throw new Error(`Nullifier membership witness not found at block ${blockNumber}.`);
+            throw new Error(`Nullifier membership witness not found at block ${blockHash}.`);
         }
         return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async utilityGetAuthWitness(foreignMessageHash) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getAuthWitness(foreignMessageHash) {
         const messageHash = fromSingle(foreignMessageHash);
-        const authWitness = await this.handlerAsUtility().utilityGetAuthWitness(messageHash);
+        const authWitness = await this.handlerAsUtility().getAuthWitness(messageHash);
         if (!authWitness) {
             throw new Error(`Auth witness not found for message hash ${messageHash}.`);
         }
@@ -305,87 +408,152 @@ export class RPCTranslator {
             toArray(authWitness)
         ]);
     }
-    privateNotifyEnqueuedPublicFunctionCall(_foreignTargetContractAddress, _foreignCalldataHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
-        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
-    }
-    privateNotifySetPublicTeardownFunctionCall(_foreignTargetContractAddress, _foreignCalldataHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
+    // eslint-disable-next-line camelcase
+    aztec_prv_assertValidPublicCalldata(_foreignCalldataHash) {
         throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
     }
-    privateNotifySetMinRevertibleSideEffectCounter(_foreignMinRevertibleSideEffectCounter) {
+    // eslint-disable-next-line camelcase
+    aztec_prv_notifyRevertiblePhaseStart(_foreignMinRevertibleSideEffectCounter) {
         throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
     }
-    async privateIsSideEffectCounterRevertible(foreignSideEffectCounter) {
+    // eslint-disable-next-line camelcase
+    async aztec_prv_isExecutionInRevertiblePhase(foreignSideEffectCounter) {
         const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
-        const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(sideEffectCounter);
+        const isRevertible = await this.handlerAsPrivate().isExecutionInRevertiblePhase(sideEffectCounter);
         return toForeignCallResult([
             toSingle(new Fr(isRevertible))
         ]);
     }
-    async utilityGetUtilityContext() {
-        const context = await this.handlerAsUtility().utilityGetUtilityContext();
+    // eslint-disable-next-line camelcase
+    aztec_utl_getUtilityContext() {
+        const context = this.handlerAsUtility().getUtilityContext();
         return toForeignCallResult(context.toNoirRepresentation());
     }
-    async utilityGetBlockHeader(foreignBlockNumber) {
-        const blockNumber = fromSingle(foreignBlockNumber).toNumber();
-        const header = await this.handlerAsUtility().utilityGetBlockHeader(blockNumber);
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getBlockHeader(foreignBlockNumber) {
+        const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
+        const header = await this.handlerAsUtility().getBlockHeader(blockNumber);
         if (!header) {
             throw new Error(`Block header not found for block ${blockNumber}.`);
         }
         return toForeignCallResult(header.toFields().map(toSingle));
     }
-    async utilityGetMembershipWitness(foreignBlockNumber, foreignTreeId, foreignLeafValue) {
-        const blockNumber = fromSingle(foreignBlockNumber).toNumber();
-        const treeId = fromSingle(foreignTreeId).toNumber();
-        const leafValue = fromSingle(foreignLeafValue);
-        const witness = await this.handlerAsUtility().utilityGetMembershipWitness(blockNumber, treeId, leafValue);
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getNoteHashMembershipWitness(foreignAnchorBlockHash, foreignNoteHash) {
+        const blockHash = blockHashFromSingle(foreignAnchorBlockHash);
+        const noteHash = fromSingle(foreignNoteHash);
+        const witness = await this.handlerAsUtility().getNoteHashMembershipWitness(blockHash, noteHash);
         if (!witness) {
-            throw new Error(`Membership witness in tree ${MerkleTreeId[treeId]} not found for value ${leafValue} at block ${blockNumber}.`);
+            throw new Error(`Note hash ${noteHash} not found in the note hash tree at block ${blockHash.toString()}.`);
         }
-        return toForeignCallResult([
-            toSingle(witness[0]),
-            toArray(witness.slice(1))
-        ]);
+        return toForeignCallResult(witness.toNoirRepresentation());
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getBlockHashMembershipWitness(foreignAnchorBlockHash, foreignBlockHash) {
+        const anchorBlockHash = blockHashFromSingle(foreignAnchorBlockHash);
+        const blockHash = blockHashFromSingle(foreignBlockHash);
+        const witness = await this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash);
+        if (!witness) {
+            throw new Error(`Block hash ${blockHash.toString()} not found in the archive tree at anchor block ${anchorBlockHash.toString()}.`);
+        }
+        return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async utilityGetLowNullifierMembershipWitness(foreignBlockNumber, foreignNullifier) {
-        const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getLowNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
+        const blockHash = blockHashFromSingle(foreignBlockHash);
         const nullifier = fromSingle(foreignNullifier);
-        const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(blockNumber, nullifier);
+        const witness = await this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier);
         if (!witness) {
-            throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockNumber}.`);
+            throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockHash}.`);
         }
         return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async utilityFetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getPendingTaggedLogs(foreignPendingTaggedLogArrayBaseSlot, foreignScope) {
         const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
-        await this.handlerAsUtility().utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        await this.handlerAsUtility().getPendingTaggedLogs(pendingTaggedLogArrayBaseSlot, scope);
         return toForeignCallResult([]);
     }
-    async utilityValidateEnqueuedNotesAndEvents(foreignContractAddress, foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getPendingTaggedLogs_v2(foreignScope) {
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        const slot = await this.handlerAsUtility().getPendingTaggedLogsV2(scope);
+        return toForeignCallResult([
+            toSingle(slot)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(foreignContractAddress, foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot, foreignMaxNotePackedLen, foreignMaxEventSerializedLen, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
         const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
-        await this.handlerAsUtility().utilityValidateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot);
+        const maxNotePackedLen = fromSingle(foreignMaxNotePackedLen).toNumber();
+        const maxEventSerializedLen = fromSingle(foreignMaxEventSerializedLen).toNumber();
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, maxNotePackedLen, maxEventSerializedLen, scope);
+        return toForeignCallResult([]);
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_utl_validateAndStoreEnqueuedNotesAndEvents_v2(foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot, foreignMaxNotePackedLen, foreignMaxEventSerializedLen, foreignScope) {
+        const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
+        const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
+        const maxNotePackedLen = fromSingle(foreignMaxNotePackedLen).toNumber();
+        const maxEventSerializedLen = fromSingle(foreignMaxEventSerializedLen).toNumber();
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEventsV2(noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, maxNotePackedLen, maxEventSerializedLen, scope);
         return toForeignCallResult([]);
     }
-    async utilityBulkRetrieveLogs(foreignContractAddress, foreignLogRetrievalRequestsArrayBaseSlot, foreignLogRetrievalResponsesArrayBaseSlot) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getLogsByTag(foreignContractAddress, foreignLogRetrievalRequestsArrayBaseSlot, foreignLogRetrievalResponsesArrayBaseSlot, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
         const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
-        await this.handlerAsUtility().utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        await this.handlerAsUtility().getLogsByTag(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot, scope);
         return toForeignCallResult([]);
     }
-    async utilityStoreCapsule(foreignContractAddress, foreignSlot, foreignCapsule) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getMessageContextsByTxHash(foreignContractAddress, foreignMessageContextRequestsArrayBaseSlot, foreignMessageContextResponsesArrayBaseSlot, foreignScope) {
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const messageContextRequestsArrayBaseSlot = fromSingle(foreignMessageContextRequestsArrayBaseSlot);
+        const messageContextResponsesArrayBaseSlot = fromSingle(foreignMessageContextResponsesArrayBaseSlot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        await this.handlerAsUtility().getMessageContextsByTxHash(contractAddress, messageContextRequestsArrayBaseSlot, messageContextResponsesArrayBaseSlot, scope);
+        return toForeignCallResult([]);
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getLogsByTag_v2(foreignRequestArrayBaseSlot) {
+        const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+        const responseSlot = await this.handlerAsUtility().getLogsByTagV2(requestArrayBaseSlot);
+        return toForeignCallResult([
+            toSingle(responseSlot)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getMessageContextsByTxHash_v2(foreignRequestArrayBaseSlot) {
+        const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+        const responseSlot = await this.handlerAsUtility().getMessageContextsByTxHashV2(requestArrayBaseSlot);
+        return toForeignCallResult([
+            toSingle(responseSlot)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setCapsule(foreignContractAddress, foreignSlot, foreignCapsule, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const slot = fromSingle(foreignSlot);
         const capsule = fromArray(foreignCapsule);
-        await this.handlerAsUtility().utilityStoreCapsule(contractAddress, slot, capsule);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        this.handlerAsUtility().setCapsule(contractAddress, slot, capsule, scope);
         return toForeignCallResult([]);
     }
-    async utilityLoadCapsule(foreignContractAddress, foreignSlot, foreignTSize) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getCapsule(foreignContractAddress, foreignSlot, foreignTSize, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const slot = fromSingle(foreignSlot);
         const tSize = fromSingle(foreignTSize).toNumber();
-        const values = await this.handlerAsUtility().utilityLoadCapsule(contractAddress, slot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        const values = await this.handlerAsUtility().getCapsule(contractAddress, slot, scope);
         // 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).
         if (values === null) {
@@ -402,197 +570,316 @@ export class RPCTranslator {
             ]);
         }
     }
-    async utilityDeleteCapsule(foreignContractAddress, foreignSlot) {
+    // eslint-disable-next-line camelcase
+    aztec_utl_deleteCapsule(foreignContractAddress, foreignSlot, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const slot = fromSingle(foreignSlot);
-        await this.handlerAsUtility().utilityDeleteCapsule(contractAddress, slot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope);
         return toForeignCallResult([]);
     }
-    async utilityCopyCapsule(foreignContractAddress, foreignSrcSlot, foreignDstSlot, foreignNumEntries) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_copyCapsule(foreignContractAddress, foreignSrcSlot, foreignDstSlot, foreignNumEntries, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const srcSlot = fromSingle(foreignSrcSlot);
         const dstSlot = fromSingle(foreignDstSlot);
         const numEntries = fromSingle(foreignNumEntries).toNumber();
-        await this.handlerAsUtility().utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        await this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, scope);
+        return toForeignCallResult([]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_pushEphemeral(foreignSlot, foreignElements) {
+        const slot = fromSingle(foreignSlot);
+        const elements = fromArray(foreignElements);
+        const newLen = this.handlerAsUtility().pushEphemeral(slot, elements);
+        return toForeignCallResult([
+            toSingle(new Fr(newLen))
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_popEphemeral(foreignSlot) {
+        const slot = fromSingle(foreignSlot);
+        const element = this.handlerAsUtility().popEphemeral(slot);
+        return toForeignCallResult([
+            toArray(element)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getEphemeral(foreignSlot, foreignIndex) {
+        const slot = fromSingle(foreignSlot);
+        const index = fromSingle(foreignIndex).toNumber();
+        const element = this.handlerAsUtility().getEphemeral(slot, index);
+        return toForeignCallResult([
+            toArray(element)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setEphemeral(foreignSlot, foreignIndex, foreignElements) {
+        const slot = fromSingle(foreignSlot);
+        const index = fromSingle(foreignIndex).toNumber();
+        const elements = fromArray(foreignElements);
+        this.handlerAsUtility().setEphemeral(slot, index, elements);
+        return toForeignCallResult([]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getEphemeralLen(foreignSlot) {
+        const slot = fromSingle(foreignSlot);
+        const len = this.handlerAsUtility().getEphemeralLen(slot);
+        return toForeignCallResult([
+            toSingle(new Fr(len))
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_removeEphemeral(foreignSlot, foreignIndex) {
+        const slot = fromSingle(foreignSlot);
+        const index = fromSingle(foreignIndex).toNumber();
+        this.handlerAsUtility().removeEphemeral(slot, index);
+        return toForeignCallResult([]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_clearEphemeral(foreignSlot) {
+        const slot = fromSingle(foreignSlot);
+        this.handlerAsUtility().clearEphemeral(slot);
         return toForeignCallResult([]);
     }
     // TODO: I forgot to add a corresponding function here, when I introduced an oracle method to txe_oracle.ts.
     // 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?
-    async utilityAes128Decrypt(foreignCiphertextBVecStorage, foreignCiphertextLength, foreignIv, foreignSymKey) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_decryptAes128(foreignCiphertextBVecStorage, foreignCiphertextLength, foreignIv, foreignSymKey) {
         const ciphertext = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
         const iv = fromUintArray(foreignIv, 8);
         const symKey = fromUintArray(foreignSymKey, 8);
-        const plaintextBuffer = await this.handlerAsUtility().utilityAes128Decrypt(ciphertext, iv, symKey);
-        return toForeignCallResult(arrayToBoundedVec(bufferToU8Array(plaintextBuffer), foreignCiphertextBVecStorage.length));
+        // Noir Option<BoundedVec> is encoded as [is_some: Field, storage: Field[], length: Field].
+        try {
+            const plaintextBuffer = await this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey);
+            const [storage, length] = arrayToBoundedVec(bufferToU8Array(plaintextBuffer), foreignCiphertextBVecStorage.length);
+            return toForeignCallResult([
+                toSingle(new Fr(1)),
+                storage,
+                length
+            ]);
+        } catch  {
+            const zeroStorage = toArray(Array(foreignCiphertextBVecStorage.length).fill(new Fr(0)));
+            return toForeignCallResult([
+                toSingle(new Fr(0)),
+                zeroStorage,
+                toSingle(new Fr(0))
+            ]);
+        }
     }
-    async utilityGetSharedSecret(foreignAddress, foreignEphPKField0, foreignEphPKField1, foreignEphPKField2) {
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getSharedSecret(foreignAddress, foreignEphPKField0, foreignEphPKField1, foreignEphPKField2, foreignContractAddress) {
         const address = AztecAddress.fromField(fromSingle(foreignAddress));
         const ephPK = Point.fromFields([
             fromSingle(foreignEphPKField0),
             fromSingle(foreignEphPKField1),
             fromSingle(foreignEphPKField2)
         ]);
-        const secret = await this.handlerAsUtility().utilityGetSharedSecret(address, ephPK);
-        return toForeignCallResult(secret.toFields().map(toSingle));
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const secret = await this.handlerAsUtility().getSharedSecret(address, ephPK, contractAddress);
+        return toForeignCallResult([
+            toSingle(secret)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setContractSyncCacheInvalid(foreignContractAddress, foreignScopes, foreignScopeCount) {
+        const contractAddress = addressFromSingle(foreignContractAddress);
+        const count = fromSingle(foreignScopeCount).toNumber();
+        const scopes = fromArray(foreignScopes).slice(0, count).map((f)=>new AztecAddress(f));
+        this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes);
+        return Promise.resolve(toForeignCallResult([]));
     }
-    emitOffchainEffect(_foreignData) {
+    // eslint-disable-next-line camelcase
+    aztec_utl_emitOffchainEffect(_foreignData) {
         throw new Error('Offchain effects are not yet supported in the TestEnvironment');
     }
     // AVM opcodes
-    avmOpcodeEmitUnencryptedLog(_foreignMessage) {
+    // eslint-disable-next-line camelcase
+    aztec_avm_emitPublicLog(_foreignMessage) {
         // TODO(#8811): Implement
         return toForeignCallResult([]);
     }
-    async avmOpcodeStorageRead(foreignSlot) {
+    // eslint-disable-next-line camelcase
+    async aztec_avm_storageRead(foreignSlot, foreignContractAddress) {
         const slot = fromSingle(foreignSlot);
-        const value = (await this.handlerAsAvm().avmOpcodeStorageRead(slot)).value;
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const value = (await this.handlerAsAvm().storageRead(slot, contractAddress)).value;
         return toForeignCallResult([
             toSingle(new Fr(value))
         ]);
     }
-    async avmOpcodeStorageWrite(foreignSlot, foreignValue) {
+    // eslint-disable-next-line camelcase
+    async aztec_avm_storageWrite(foreignSlot, foreignValue) {
         const slot = fromSingle(foreignSlot);
         const value = fromSingle(foreignValue);
-        await this.handlerAsAvm().avmOpcodeStorageWrite(slot, value);
+        await this.handlerAsAvm().storageWrite(slot, value);
         return toForeignCallResult([]);
     }
-    async avmOpcodeGetContractInstanceDeployer(foreignAddress) {
+    // eslint-disable-next-line camelcase
+    async aztec_avm_getContractInstanceDeployer(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
+        const instance = await this.handlerAsUtility().getContractInstance(address);
         return toForeignCallResult([
             toSingle(instance.deployer),
             // AVM requires an extra boolean indicating the instance was found
             toSingle(new Fr(1))
         ]);
     }
-    async avmOpcodeGetContractInstanceClassId(foreignAddress) {
+    // eslint-disable-next-line camelcase
+    async aztec_avm_getContractInstanceClassId(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
+        const instance = await this.handlerAsUtility().getContractInstance(address);
         return toForeignCallResult([
             toSingle(instance.currentContractClassId),
             // AVM requires an extra boolean indicating the instance was found
             toSingle(new Fr(1))
         ]);
     }
-    async avmOpcodeGetContractInstanceInitializationHash(foreignAddress) {
+    // eslint-disable-next-line camelcase
+    async aztec_avm_getContractInstanceInitializationHash(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
+        const instance = await this.handlerAsUtility().getContractInstance(address);
         return toForeignCallResult([
             toSingle(instance.initializationHash),
             // AVM requires an extra boolean indicating the instance was found
             toSingle(new Fr(1))
         ]);
     }
-    async avmOpcodeSender() {
-        const sender = await this.handlerAsAvm().avmOpcodeSender();
+    // eslint-disable-next-line camelcase
+    async aztec_avm_sender() {
+        const sender = await this.handlerAsAvm().sender();
         return toForeignCallResult([
             toSingle(sender)
         ]);
     }
-    async avmOpcodeEmitNullifier(foreignNullifier) {
+    // eslint-disable-next-line camelcase
+    async aztec_avm_emitNullifier(foreignNullifier) {
         const nullifier = fromSingle(foreignNullifier);
-        await this.handlerAsAvm().avmOpcodeEmitNullifier(nullifier);
+        await this.handlerAsAvm().emitNullifier(nullifier);
         return toForeignCallResult([]);
     }
-    async avmOpcodeEmitNoteHash(foreignNoteHash) {
+    // eslint-disable-next-line camelcase
+    async aztec_avm_emitNoteHash(foreignNoteHash) {
         const noteHash = fromSingle(foreignNoteHash);
-        await this.handlerAsAvm().avmOpcodeEmitNoteHash(noteHash);
+        await this.handlerAsAvm().emitNoteHash(noteHash);
         return toForeignCallResult([]);
     }
-    async avmOpcodeNullifierExists(foreignInnerNullifier, foreignTargetAddress) {
-        const innerNullifier = fromSingle(foreignInnerNullifier);
-        const targetAddress = AztecAddress.fromField(fromSingle(foreignTargetAddress));
-        const exists = await this.handlerAsAvm().avmOpcodeNullifierExists(innerNullifier, targetAddress);
+    // eslint-disable-next-line camelcase
+    async aztec_avm_nullifierExists(foreignSiloedNullifier) {
+        const siloedNullifier = fromSingle(foreignSiloedNullifier);
+        const exists = await this.handlerAsAvm().nullifierExists(siloedNullifier);
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
-    async avmOpcodeAddress() {
-        const contractAddress = await this.handlerAsAvm().avmOpcodeAddress();
+    // eslint-disable-next-line camelcase
+    async aztec_avm_address() {
+        const contractAddress = await this.handlerAsAvm().address();
         return toForeignCallResult([
             toSingle(contractAddress.toField())
         ]);
     }
-    async avmOpcodeBlockNumber() {
-        const blockNumber = await this.handlerAsAvm().avmOpcodeBlockNumber();
+    // eslint-disable-next-line camelcase
+    async aztec_avm_blockNumber() {
+        const blockNumber = await this.handlerAsAvm().blockNumber();
         return toForeignCallResult([
             toSingle(new Fr(blockNumber))
         ]);
     }
-    async avmOpcodeTimestamp() {
-        const timestamp = await this.handlerAsAvm().avmOpcodeTimestamp();
+    // eslint-disable-next-line camelcase
+    async aztec_avm_timestamp() {
+        const timestamp = await this.handlerAsAvm().timestamp();
         return toForeignCallResult([
             toSingle(new Fr(timestamp))
         ]);
     }
-    async avmOpcodeIsStaticCall() {
-        const isStaticCall = await this.handlerAsAvm().avmOpcodeIsStaticCall();
+    // eslint-disable-next-line camelcase
+    async aztec_avm_isStaticCall() {
+        const isStaticCall = await this.handlerAsAvm().isStaticCall();
         return toForeignCallResult([
             toSingle(new Fr(isStaticCall ? 1 : 0))
         ]);
     }
-    async avmOpcodeChainId() {
-        const chainId = await this.handlerAsAvm().avmOpcodeChainId();
+    // eslint-disable-next-line camelcase
+    async aztec_avm_chainId() {
+        const chainId = await this.handlerAsAvm().chainId();
         return toForeignCallResult([
             toSingle(chainId)
         ]);
     }
-    async avmOpcodeVersion() {
-        const version = await this.handlerAsAvm().avmOpcodeVersion();
+    // eslint-disable-next-line camelcase
+    async aztec_avm_version() {
+        const version = await this.handlerAsAvm().version();
         return toForeignCallResult([
             toSingle(version)
         ]);
     }
-    avmOpcodeReturndataSize() {
+    // eslint-disable-next-line camelcase
+    aztec_avm_returndataSize() {
         throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    avmOpcodeReturndataCopy(_foreignRdOffset, _foreignCopySize) {
+    // eslint-disable-next-line camelcase
+    aztec_avm_returndataCopy(_foreignRdOffset, _foreignCopySize) {
         throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    avmOpcodeCall(_foreignL2Gas, _foreignDaGas, _foreignAddress, _foreignLength, _foreignArgs) {
+    // eslint-disable-next-line camelcase
+    aztec_avm_call(_foreignL2Gas, _foreignDaGas, _foreignAddress, _foreignLength, _foreignArgs) {
         throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    avmOpcodeStaticCall(_foreignL2Gas, _foreignDaGas, _foreignAddress, _foreignLength, _foreignArgs) {
+    // eslint-disable-next-line camelcase
+    aztec_avm_staticCall(_foreignL2Gas, _foreignDaGas, _foreignAddress, _foreignLength, _foreignArgs) {
         throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    avmOpcodeSuccessCopy() {
+    // eslint-disable-next-line camelcase
+    aztec_avm_successCopy() {
         throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    async txePrivateCallNewFlow(foreignFrom, foreignTargetContractAddress, foreignFunctionSelector, foreignArgs, foreignArgsHash, foreignIsStaticCall) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_privateCallNewFlow(foreignFrom, foreignTargetContractAddress, foreignFunctionSelector, foreignArgs, foreignArgsHash, foreignIsStaticCall) {
         const from = addressFromSingle(foreignFrom);
         const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
         const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
         const args = fromArray(foreignArgs);
         const argsHash = fromSingle(foreignArgsHash);
         const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const returnValues = await this.handlerAsTxe().txePrivateCallNewFlow(from, targetContractAddress, functionSelector, args, argsHash, isStaticCall);
+        const returnValues = await this.handlerAsTxe().privateCallNewFlow(from, targetContractAddress, functionSelector, args, argsHash, isStaticCall, this.stateHandler.getCurrentJob());
+        // TODO(F-335): Avoid doing the following call here.
+        await this.stateHandler.cycleJob();
         return toForeignCallResult([
             toArray(returnValues)
         ]);
     }
-    async txeSimulateUtilityFunction(foreignTargetContractAddress, foreignFunctionSelector, foreignArgs) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_executeUtilityFunction(foreignTargetContractAddress, foreignFunctionSelector, foreignArgs) {
         const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
         const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
         const args = fromArray(foreignArgs);
-        const returnValues = await this.handlerAsTxe().txeSimulateUtilityFunction(targetContractAddress, functionSelector, args);
+        const returnValues = await this.handlerAsTxe().executeUtilityFunction(targetContractAddress, functionSelector, args, this.stateHandler.getCurrentJob());
+        // TODO(F-335): Avoid doing the following call here.
+        await this.stateHandler.cycleJob();
         return toForeignCallResult([
             toArray(returnValues)
         ]);
     }
-    async txePublicCallNewFlow(foreignFrom, foreignAddress, foreignCalldata, foreignIsStaticCall) {
+    // eslint-disable-next-line camelcase
+    async aztec_txe_publicCallNewFlow(foreignFrom, foreignAddress, foreignCalldata, foreignIsStaticCall) {
         const from = addressFromSingle(foreignFrom);
         const address = addressFromSingle(foreignAddress);
         const calldata = fromArray(foreignCalldata);
         const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const returnValues = await this.handlerAsTxe().txePublicCallNewFlow(from, address, calldata, isStaticCall);
+        const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall);
+        // TODO(F-335): Avoid doing the following call here.
+        await this.stateHandler.cycleJob();
         return toForeignCallResult([
             toArray(returnValues)
         ]);
     }
-    async privateGetSenderForTags() {
-        const sender = await this.handlerAsPrivate().privateGetSenderForTags();
+    // eslint-disable-next-line camelcase
+    async aztec_prv_getSenderForTags() {
+        const sender = await this.handlerAsPrivate().getSenderForTags();
         // Return a Noir Option struct with `some` and `value` fields
         if (sender === undefined) {
             // No sender found, return Option with some=0 and value=0
@@ -608,15 +895,17 @@ export class RPCTranslator {
             ]);
         }
     }
-    async privateSetSenderForTags(foreignSenderForTags) {
+    // eslint-disable-next-line camelcase
+    async aztec_prv_setSenderForTags(foreignSenderForTags) {
         const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
-        await this.handlerAsPrivate().privateSetSenderForTags(senderForTags);
+        await this.handlerAsPrivate().setSenderForTags(senderForTags);
         return toForeignCallResult([]);
     }
-    async privateGetNextAppTagAsSender(foreignSender, foreignRecipient) {
+    // eslint-disable-next-line camelcase
+    async aztec_prv_getNextAppTagAsSender(foreignSender, foreignRecipient) {
         const sender = AztecAddress.fromField(fromSingle(foreignSender));
         const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
-        const nextAppTag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(sender, recipient);
+        const nextAppTag = await this.handlerAsPrivate().getNextAppTagAsSender(sender, recipient);
         return toForeignCallResult([
             toSingle(nextAppTag.value)
         ]);