@aztec/txe 0.0.0-test.1 → 0.0.1-commit.0b941701

package/dest/rpc_translator.js

@@ -0,0 +1,680 @@
+import { Fr, Point } from '@aztec/aztec.js/fields';
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
+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 { L2BlockHash } from '@aztec/stdlib/block';
+import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } from './util/encoding.js';
+const MAX_EVENT_LEN = 12; // This is MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_RESERVED_FIELDS
+const MAX_PRIVATE_EVENTS_PER_TXE_QUERY = 5;
+export class UnavailableOracleError extends Error {
+    constructor(oracleName){
+        super(`${oracleName} oracles not available with the current handler`);
+    }
+}
+export class RPCTranslator {
+    stateHandler;
+    oracleHandler;
+    /**
+   * Create a new instance of `RPCTranslator` that will translate all TXE RPC calls to and from the foreign
+   * (`ForeignCallSingle`, `ForeignCallResult`, etc.) and native TS types, delegating actual execution of the oracles
+   * to the different handlers.
+   * @param stateHandler The handler that will process TXE session state transitions, such as entering a private or
+   * public context.
+   * @param oracleHandler The handler that will process all other oracle calls that are not directly related to session
+   * state.
+   */ constructor(stateHandler, oracleHandler){
+        this.stateHandler = stateHandler;
+        this.oracleHandler = oracleHandler;
+    }
+    // Note: If you rename the following functions to not start with "handlerAs", you must also update the validation
+    // check in `TXESession.processFunction`.
+    handlerAsMisc() {
+        if (!('isMisc' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Misc');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsUtility() {
+        if (!('isUtility' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Utility');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsPrivate() {
+        if (!('isPrivate' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Private');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsAvm() {
+        if (!('isAvm' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Avm');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsTxe() {
+        if (!('isTxe' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Txe');
+        }
+        return this.oracleHandler;
+    }
+    // TXE session state transition functions - these get handled by the state handler
+    async txeSetTopLevelTXEContext() {
+        await this.stateHandler.enterTopLevelState();
+        return toForeignCallResult([]);
+    }
+    async txeSetPrivateTXEContext(foreignContractAddressIsSome, foreignContractAddressValue, foreignAnchorBlockNumberIsSome, foreignAnchorBlockNumberValue) {
+        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : 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) {
+        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
+        await this.stateHandler.enterPublicState(contractAddress);
+        return toForeignCallResult([]);
+    }
+    async txeSetUtilityTXEContext(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
+    txeGetDefaultAddress() {
+        const defaultAddress = this.handlerAsTxe().txeGetDefaultAddress();
+        return toForeignCallResult([
+            toSingle(defaultAddress)
+        ]);
+    }
+    async txeGetNextBlockNumber() {
+        const nextBlockNumber = await this.handlerAsTxe().txeGetNextBlockNumber();
+        return toForeignCallResult([
+            toSingle(nextBlockNumber)
+        ]);
+    }
+    async txeGetNextBlockTimestamp() {
+        const nextBlockTimestamp = await this.handlerAsTxe().txeGetNextBlockTimestamp();
+        return toForeignCallResult([
+            toSingle(nextBlockTimestamp)
+        ]);
+    }
+    async txeAdvanceBlocksBy(foreignBlocks) {
+        const blocks = fromSingle(foreignBlocks).toNumber();
+        await this.handlerAsTxe().txeAdvanceBlocksBy(blocks);
+        return toForeignCallResult([]);
+    }
+    txeAdvanceTimestampBy(foreignDuration) {
+        const duration = fromSingle(foreignDuration).toBigInt();
+        this.handlerAsTxe().txeAdvanceTimestampBy(duration);
+        return toForeignCallResult([]);
+    }
+    async txeDeploy(artifact, instance, foreignSecret) {
+        const secret = fromSingle(foreignSecret);
+        await this.handlerAsTxe().txeDeploy(artifact, instance, secret);
+        return toForeignCallResult([
+            toArray([
+                instance.salt,
+                instance.deployer.toField(),
+                instance.currentContractClassId,
+                instance.initializationHash,
+                ...instance.publicKeys.toFields()
+            ])
+        ]);
+    }
+    async txeCreateAccount(foreignSecret) {
+        const secret = fromSingle(foreignSecret);
+        const completeAddress = await this.handlerAsTxe().txeCreateAccount(secret);
+        return toForeignCallResult([
+            toSingle(completeAddress.address),
+            ...completeAddress.publicKeys.toFields().map(toSingle)
+        ]);
+    }
+    async txeAddAccount(artifact, instance, foreignSecret) {
+        const secret = fromSingle(foreignSecret);
+        const completeAddress = await this.handlerAsTxe().txeAddAccount(artifact, instance, secret);
+        return toForeignCallResult([
+            toSingle(completeAddress.address),
+            ...completeAddress.publicKeys.toFields().map(toSingle)
+        ]);
+    }
+    async txeAddAuthWitness(foreignAddress, foreignMessageHash) {
+        const address = addressFromSingle(foreignAddress);
+        const messageHash = fromSingle(foreignMessageHash);
+        await this.handlerAsTxe().txeAddAuthWitness(address, messageHash);
+        return toForeignCallResult([]);
+    }
+    // PXE oracles
+    utilityAssertCompatibleOracleVersion(foreignVersion) {
+        const version = fromSingle(foreignVersion).toNumber();
+        this.handlerAsMisc().utilityAssertCompatibleOracleVersion(version);
+        return toForeignCallResult([]);
+    }
+    utilityGetRandomField() {
+        const randomField = this.handlerAsMisc().utilityGetRandomField();
+        return toForeignCallResult([
+            toSingle(randomField)
+        ]);
+    }
+    async txeGetLastBlockTimestamp() {
+        const timestamp = await this.handlerAsTxe().txeGetLastBlockTimestamp();
+        return toForeignCallResult([
+            toSingle(new Fr(timestamp))
+        ]);
+    }
+    async txeGetLastTxEffects() {
+        const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().txeGetLastTxEffects();
+        return toForeignCallResult([
+            toSingle(txHash.hash),
+            ...arrayToBoundedVec(toArray(noteHashes), MAX_NOTE_HASHES_PER_TX),
+            ...arrayToBoundedVec(toArray(nullifiers), MAX_NULLIFIERS_PER_TX)
+        ]);
+    }
+    async txeGetPrivateEvents(foreignSelector, foreignContractAddress, foreignScope) {
+        const selector = EventSelector.fromField(fromSingle(foreignSelector));
+        const contractAddress = addressFromSingle(foreignContractAddress);
+        const scope = addressFromSingle(foreignScope);
+        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}`);
+        }
+        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)
+        ]);
+    }
+    privateStoreInExecutionCache(foreignValues, foreignHash) {
+        const values = fromArray(foreignValues);
+        const hash = fromSingle(foreignHash);
+        this.handlerAsPrivate().privateStoreInExecutionCache(values, hash);
+        return toForeignCallResult([]);
+    }
+    async privateLoadFromExecutionCache(foreignHash) {
+        const hash = fromSingle(foreignHash);
+        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.
+    utilityDebugLog(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);
+        return toForeignCallResult([]);
+    }
+    async utilityStorageRead(foreignBlockHash, foreignContractAddress, foreignStartStorageSlot, foreignNumberOfElements) {
+        const blockHash = L2BlockHash.fromString(foreignBlockHash);
+        const contractAddress = addressFromSingle(foreignContractAddress);
+        const startStorageSlot = fromSingle(foreignStartStorageSlot);
+        const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
+        const values = await this.handlerAsUtility().utilityStorageRead(blockHash, contractAddress, startStorageSlot, numberOfElements);
+        return toForeignCallResult([
+            toArray(values)
+        ]);
+    }
+    async utilityGetPublicDataWitness(foreignBlockHash, foreignLeafSlot) {
+        const blockHash = L2BlockHash.fromString(foreignBlockHash);
+        const leafSlot = fromSingle(foreignLeafSlot);
+        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()}.`);
+        }
+        return toForeignCallResult(witness.toNoirRepresentation());
+    }
+    async utilityGetNotes(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());
+        const selectByOffsets = fromArray(foreignSelectByOffsets).map((fr)=>fr.toNumber());
+        const selectByLengths = fromArray(foreignSelectByLengths).map((fr)=>fr.toNumber());
+        const selectValues = fromArray(foreignSelectValues);
+        const selectComparators = fromArray(foreignSelectComparators).map((fr)=>fr.toNumber());
+        const sortByIndexes = fromArray(foreignSortByIndexes).map((fr)=>fr.toNumber());
+        const sortByOffsets = fromArray(foreignSortByOffsets).map((fr)=>fr.toNumber());
+        const sortByLengths = fromArray(foreignSortByLengths).map((fr)=>fr.toNumber());
+        const sortOrder = fromArray(foreignSortOrder).map((fr)=>fr.toNumber());
+        const limit = fromSingle(foreignLimit).toNumber();
+        const offset = fromSingle(foreignOffset).toNumber();
+        const status = fromSingle(foreignStatus).toNumber();
+        const maxNotes = fromSingle(foreignMaxNotes).toNumber();
+        const packedHintedNoteLength = fromSingle(foreignPackedHintedNoteLength).toNumber();
+        const noteDatas = await this.handlerAsUtility().utilityGetNotes(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, packedHintedNoteLength));
+    }
+    privateNotifyCreatedNote(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(owner, storageSlot, randomness, noteTypeId, note, noteHash, counter);
+        return toForeignCallResult([]);
+    }
+    async privateNotifyNullifiedNote(foreignInnerNullifier, foreignNoteHash, foreignCounter) {
+        const innerNullifier = fromSingle(foreignInnerNullifier);
+        const noteHash = fromSingle(foreignNoteHash);
+        const counter = fromSingle(foreignCounter).toNumber();
+        await this.handlerAsPrivate().privateNotifyNullifiedNote(innerNullifier, noteHash, counter);
+        return toForeignCallResult([]);
+    }
+    async privateNotifyCreatedNullifier(foreignInnerNullifier) {
+        const innerNullifier = fromSingle(foreignInnerNullifier);
+        await this.handlerAsPrivate().privateNotifyCreatedNullifier(innerNullifier);
+        return toForeignCallResult([]);
+    }
+    async privateIsNullifierPending(foreignInnerNullifier, foreignContractAddress) {
+        const innerNullifier = fromSingle(foreignInnerNullifier);
+        const contractAddress = addressFromSingle(foreignContractAddress);
+        const isPending = await this.handlerAsPrivate().privateIsNullifierPending(innerNullifier, contractAddress);
+        return toForeignCallResult([
+            toSingle(new Fr(isPending))
+        ]);
+    }
+    async utilityCheckNullifierExists(foreignInnerNullifier) {
+        const innerNullifier = fromSingle(foreignInnerNullifier);
+        const exists = await this.handlerAsUtility().utilityCheckNullifierExists(innerNullifier);
+        return toForeignCallResult([
+            toSingle(new Fr(exists))
+        ]);
+    }
+    async utilityGetContractInstance(foreignAddress) {
+        const address = addressFromSingle(foreignAddress);
+        const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
+        return toForeignCallResult([
+            instance.salt,
+            instance.deployer.toField(),
+            instance.currentContractClassId,
+            instance.initializationHash,
+            ...instance.publicKeys.toFields()
+        ].map(toSingle));
+    }
+    async utilityGetPublicKeysAndPartialAddress(foreignAddress) {
+        const address = addressFromSingle(foreignAddress);
+        const { publicKeys, partialAddress } = await this.handlerAsUtility().utilityGetPublicKeysAndPartialAddress(address);
+        return toForeignCallResult([
+            toArray([
+                ...publicKeys.toFields(),
+                partialAddress
+            ])
+        ]);
+    }
+    async utilityGetKeyValidationRequest(foreignPkMHash) {
+        const pkMHash = fromSingle(foreignPkMHash);
+        const keyValidationRequest = await this.handlerAsUtility().utilityGetKeyValidationRequest(pkMHash);
+        return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
+    }
+    privateCallPrivateFunction(_foreignTargetContractAddress, _foreignFunctionSelector, _foreignArgsHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::private_context`, use `private_call` instead');
+    }
+    async utilityGetNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
+        const blockHash = L2BlockHash.fromString(foreignBlockHash);
+        const nullifier = fromSingle(foreignNullifier);
+        const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(blockHash, nullifier);
+        if (!witness) {
+            throw new Error(`Nullifier membership witness not found at block ${blockHash}.`);
+        }
+        return toForeignCallResult(witness.toNoirRepresentation());
+    }
+    async utilityGetAuthWitness(foreignMessageHash) {
+        const messageHash = fromSingle(foreignMessageHash);
+        const authWitness = await this.handlerAsUtility().utilityGetAuthWitness(messageHash);
+        if (!authWitness) {
+            throw new Error(`Auth witness not found for message hash ${messageHash}.`);
+        }
+        return toForeignCallResult([
+            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) {
+        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+    }
+    privateNotifySetMinRevertibleSideEffectCounter(_foreignMinRevertibleSideEffectCounter) {
+        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+    }
+    async privateIsSideEffectCounterRevertible(foreignSideEffectCounter) {
+        const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
+        const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(sideEffectCounter);
+        return toForeignCallResult([
+            toSingle(new Fr(isRevertible))
+        ]);
+    }
+    utilityGetUtilityContext() {
+        const context = this.handlerAsUtility().utilityGetUtilityContext();
+        return toForeignCallResult(context.toNoirRepresentation());
+    }
+    async utilityGetBlockHeader(foreignBlockNumber) {
+        const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
+        const header = await this.handlerAsUtility().utilityGetBlockHeader(blockNumber);
+        if (!header) {
+            throw new Error(`Block header not found for block ${blockNumber}.`);
+        }
+        return toForeignCallResult(header.toFields().map(toSingle));
+    }
+    async utilityGetNoteHashMembershipWitness(foreignBlockHash, foreignLeafValue) {
+        const blockHash = L2BlockHash.fromString(foreignBlockHash);
+        const leafValue = fromSingle(foreignLeafValue);
+        const witness = await this.handlerAsUtility().utilityGetNoteHashMembershipWitness(blockHash, leafValue);
+        if (!witness) {
+            throw new Error(`Note hash ${leafValue} not found in the note hash tree at block ${blockHash.toString()}.`);
+        }
+        return toForeignCallResult(witness.toNoirRepresentation());
+    }
+    async utilityGetArchiveMembershipWitness(foreignBlockHash, foreignLeafValue) {
+        const blockHash = L2BlockHash.fromString(foreignBlockHash);
+        const leafValue = fromSingle(foreignLeafValue);
+        const witness = await this.handlerAsUtility().utilityGetArchiveMembershipWitness(blockHash, leafValue);
+        if (!witness) {
+            throw new Error(`Block hash ${leafValue} not found in the archive tree at block ${blockHash.toString()}.`);
+        }
+        return toForeignCallResult(witness.toNoirRepresentation());
+    }
+    async utilityGetLowNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
+        const blockHash = L2BlockHash.fromString(foreignBlockHash);
+        const nullifier = fromSingle(foreignNullifier);
+        const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(blockHash, nullifier);
+        if (!witness) {
+            throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockHash}.`);
+        }
+        return toForeignCallResult(witness.toNoirRepresentation());
+    }
+    async utilityFetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot) {
+        const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
+        await this.handlerAsUtility().utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
+        return toForeignCallResult([]);
+    }
+    async utilityValidateAndStoreEnqueuedNotesAndEvents(foreignContractAddress, foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot) {
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
+        const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
+        await this.handlerAsUtility().utilityValidateAndStoreEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot);
+        return toForeignCallResult([]);
+    }
+    async utilityBulkRetrieveLogs(foreignContractAddress, foreignLogRetrievalRequestsArrayBaseSlot, foreignLogRetrievalResponsesArrayBaseSlot) {
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
+        const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
+        await this.handlerAsUtility().utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot);
+        return toForeignCallResult([]);
+    }
+    async utilityStoreCapsule(foreignContractAddress, foreignSlot, foreignCapsule) {
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const slot = fromSingle(foreignSlot);
+        const capsule = fromArray(foreignCapsule);
+        await this.handlerAsUtility().utilityStoreCapsule(contractAddress, slot, capsule);
+        return toForeignCallResult([]);
+    }
+    async utilityLoadCapsule(foreignContractAddress, foreignSlot, foreignTSize) {
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const slot = fromSingle(foreignSlot);
+        const tSize = fromSingle(foreignTSize).toNumber();
+        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).
+        if (values === null) {
+            // 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(tSize).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(values)
+            ]);
+        }
+    }
+    async utilityDeleteCapsule(foreignContractAddress, foreignSlot) {
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const slot = fromSingle(foreignSlot);
+        await this.handlerAsUtility().utilityDeleteCapsule(contractAddress, slot);
+        return toForeignCallResult([]);
+    }
+    async utilityCopyCapsule(foreignContractAddress, foreignSrcSlot, foreignDstSlot, foreignNumEntries) {
+        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);
+        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) {
+        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));
+    }
+    async utilityGetSharedSecret(foreignAddress, foreignEphPKField0, foreignEphPKField1, foreignEphPKField2) {
+        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));
+    }
+    emitOffchainEffect(_foreignData) {
+        throw new Error('Offchain effects are not yet supported in the TestEnvironment');
+    }
+    // AVM opcodes
+    avmOpcodeEmitUnencryptedLog(_foreignMessage) {
+        // TODO(#8811): Implement
+        return toForeignCallResult([]);
+    }
+    async avmOpcodeStorageRead(foreignSlot, foreignContractAddress) {
+        const slot = fromSingle(foreignSlot);
+        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+        const value = (await this.handlerAsAvm().avmOpcodeStorageRead(slot, contractAddress)).value;
+        return toForeignCallResult([
+            toSingle(new Fr(value))
+        ]);
+    }
+    async avmOpcodeStorageWrite(foreignSlot, foreignValue) {
+        const slot = fromSingle(foreignSlot);
+        const value = fromSingle(foreignValue);
+        await this.handlerAsAvm().avmOpcodeStorageWrite(slot, value);
+        return toForeignCallResult([]);
+    }
+    async avmOpcodeGetContractInstanceDeployer(foreignAddress) {
+        const address = addressFromSingle(foreignAddress);
+        const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
+        return toForeignCallResult([
+            toSingle(instance.deployer),
+            // AVM requires an extra boolean indicating the instance was found
+            toSingle(new Fr(1))
+        ]);
+    }
+    async avmOpcodeGetContractInstanceClassId(foreignAddress) {
+        const address = addressFromSingle(foreignAddress);
+        const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
+        return toForeignCallResult([
+            toSingle(instance.currentContractClassId),
+            // AVM requires an extra boolean indicating the instance was found
+            toSingle(new Fr(1))
+        ]);
+    }
+    async avmOpcodeGetContractInstanceInitializationHash(foreignAddress) {
+        const address = addressFromSingle(foreignAddress);
+        const instance = await this.handlerAsUtility().utilityGetContractInstance(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();
+        return toForeignCallResult([
+            toSingle(sender)
+        ]);
+    }
+    async avmOpcodeEmitNullifier(foreignNullifier) {
+        const nullifier = fromSingle(foreignNullifier);
+        await this.handlerAsAvm().avmOpcodeEmitNullifier(nullifier);
+        return toForeignCallResult([]);
+    }
+    async avmOpcodeEmitNoteHash(foreignNoteHash) {
+        const noteHash = fromSingle(foreignNoteHash);
+        await this.handlerAsAvm().avmOpcodeEmitNoteHash(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);
+        return toForeignCallResult([
+            toSingle(new Fr(exists))
+        ]);
+    }
+    async avmOpcodeAddress() {
+        const contractAddress = await this.handlerAsAvm().avmOpcodeAddress();
+        return toForeignCallResult([
+            toSingle(contractAddress.toField())
+        ]);
+    }
+    async avmOpcodeBlockNumber() {
+        const blockNumber = await this.handlerAsAvm().avmOpcodeBlockNumber();
+        return toForeignCallResult([
+            toSingle(new Fr(blockNumber))
+        ]);
+    }
+    async avmOpcodeTimestamp() {
+        const timestamp = await this.handlerAsAvm().avmOpcodeTimestamp();
+        return toForeignCallResult([
+            toSingle(new Fr(timestamp))
+        ]);
+    }
+    async avmOpcodeIsStaticCall() {
+        const isStaticCall = await this.handlerAsAvm().avmOpcodeIsStaticCall();
+        return toForeignCallResult([
+            toSingle(new Fr(isStaticCall ? 1 : 0))
+        ]);
+    }
+    async avmOpcodeChainId() {
+        const chainId = await this.handlerAsAvm().avmOpcodeChainId();
+        return toForeignCallResult([
+            toSingle(chainId)
+        ]);
+    }
+    async avmOpcodeVersion() {
+        const version = await this.handlerAsAvm().avmOpcodeVersion();
+        return toForeignCallResult([
+            toSingle(version)
+        ]);
+    }
+    avmOpcodeReturndataSize() {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
+    }
+    avmOpcodeReturndataCopy(_foreignRdOffset, _foreignCopySize) {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
+    }
+    avmOpcodeCall(_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) {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
+    }
+    avmOpcodeSuccessCopy() {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
+    }
+    async txePrivateCallNewFlow(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);
+        return toForeignCallResult([
+            toArray(returnValues)
+        ]);
+    }
+    async txeSimulateUtilityFunction(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);
+        return toForeignCallResult([
+            toArray(returnValues)
+        ]);
+    }
+    async txePublicCallNewFlow(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);
+        return toForeignCallResult([
+            toArray(returnValues)
+        ]);
+    }
+    async privateGetSenderForTags() {
+        const sender = await this.handlerAsPrivate().privateGetSenderForTags();
+        // Return a Noir Option struct with `some` and `value` fields
+        if (sender === undefined) {
+            // No sender found, return Option with some=0 and value=0
+            return toForeignCallResult([
+                toSingle(0),
+                toSingle(0)
+            ]);
+        } else {
+            // Sender found, return Option with some=1 and value=sender address
+            return toForeignCallResult([
+                toSingle(1),
+                toSingle(sender)
+            ]);
+        }
+    }
+    async privateSetSenderForTags(foreignSenderForTags) {
+        const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
+        await this.handlerAsPrivate().privateSetSenderForTags(senderForTags);
+        return toForeignCallResult([]);
+    }
+    async privateGetNextAppTagAsSender(foreignSender, foreignRecipient) {
+        const sender = AztecAddress.fromField(fromSingle(foreignSender));
+        const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
+        const nextAppTag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(sender, recipient);
+        return toForeignCallResult([
+            toSingle(nextAppTag.value)
+        ]);
+    }
+}