@aztec/txe 1.2.1 → 2.0.0-nightly.20250814

package/dest/txe_service/txe_service.js

@@ -1,74 +1,122 @@
 import { Fr, Point } from '@aztec/aztec.js';
-import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { enrichPublicSimulationError } from '@aztec/pxe/server';
+import { packAsRetrievedNote } from '@aztec/pxe/simulator';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
-import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computePartialAddress } from '@aztec/stdlib/contract';
-import { SimulationError } from '@aztec/stdlib/errors';
-import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { TXE } from '../oracle/txe_oracle.js';
 import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } from '../util/encoding.js';
-import { ExpectedFailureError } from '../util/expected_failure_error.js';
+var TXEContext = /*#__PURE__*/ function(TXEContext) {
+    TXEContext[TXEContext["TOP_LEVEL"] = 0] = "TOP_LEVEL";
+    TXEContext[TXEContext["PRIVATE"] = 1] = "PRIVATE";
+    TXEContext[TXEContext["PUBLIC"] = 2] = "PUBLIC";
+    TXEContext[TXEContext["UTILITY"] = 3] = "UTILITY";
+    return TXEContext;
+}(TXEContext || {});
 export class TXEService {
     logger;
-    typedOracle;
-    oraclesEnabled;
-    constructor(logger, typedOracle){
+    txe;
+    context;
+    contextChecksEnabled;
+    constructor(logger, txe){
         this.logger = logger;
-        this.typedOracle = typedOracle;
-        this.oraclesEnabled = true;
+        this.txe = txe;
+        this.context = 0;
+        this.contextChecksEnabled = false;
     }
     static async init(logger, protocolContracts) {
         logger.debug(`TXE service initialized`);
         const store = await openTmpStore('test');
         const txe = await TXE.create(logger, store, protocolContracts);
         const service = new TXEService(logger, txe);
-        await service.advanceBlocksBy(toSingle(new Fr(1n)));
+        await service.txeAdvanceBlocksBy(toSingle(new Fr(1n)));
         return service;
     }
+    // TXE Context manipulation
+    // Temporary workaround - once all tests migrate to calling the new flow, in which this oracle is called at the
+    // beginning of a txe test, we'll make the context check be mandatory
+    txeEnableContextChecks() {
+        this.contextChecksEnabled = true;
+        return toForeignCallResult([]);
+    }
+    txeSetTopLevelTXEContext() {
+        if (this.contextChecksEnabled) {
+            if (this.context == 0) {
+                throw new Error(`Call to txeSetTopLevelTXEContext while in context ${TXEContext[this.context]}`);
+            }
+        }
+        this.context = 0;
+        return toForeignCallResult([]);
+    }
+    txeSetPrivateTXEContext() {
+        if (this.contextChecksEnabled) {
+            if (this.context != 0) {
+                throw new Error(`Call to txeSetPrivateTXEContext while in context ${TXEContext[this.context]}`);
+            }
+        }
+        this.context = 1;
+        return toForeignCallResult([]);
+    }
+    txeSetPublicTXEContext() {
+        if (this.contextChecksEnabled) {
+            if (this.context != 0) {
+                throw new Error(`Call to txeSetPublicTXEContext while in context ${TXEContext[this.context]}`);
+            }
+        }
+        this.context = 2;
+        return toForeignCallResult([]);
+    }
+    txeSetUtilityTXEContext() {
+        if (this.contextChecksEnabled) {
+            if (this.context != 0) {
+                throw new Error(`Call to txeSetUtilityTXEContext while in context ${TXEContext[this.context]}`);
+            }
+        }
+        this.context = 3;
+        return toForeignCallResult([]);
+    }
     // Cheatcodes
-    async getPrivateContextInputs(blockNumberIsSome, blockNumberValue, timestampIsSome, timestampValue) {
+    async txeGetPrivateContextInputs(blockNumberIsSome, blockNumberValue) {
         const blockNumber = fromSingle(blockNumberIsSome).toBool() ? fromSingle(blockNumberValue).toNumber() : null;
-        const timestamp = fromSingle(timestampIsSome).toBool() ? fromSingle(timestampValue).toBigInt() : null;
-        const inputs = await this.typedOracle.getPrivateContextInputs(blockNumber, timestamp);
+        const inputs = await this.txe.txeGetPrivateContextInputs(blockNumber);
+        this.logger.info(`Created private context for block ${inputs.historicalHeader.globalVariables.blockNumber} (requested ${blockNumber})`);
         return toForeignCallResult(inputs.toFields().map(toSingle));
     }
-    async advanceBlocksBy(blocks) {
+    async txeAdvanceBlocksBy(blocks) {
         const nBlocks = fromSingle(blocks).toNumber();
         this.logger.debug(`time traveling ${nBlocks} blocks`);
         for(let i = 0; i < nBlocks; i++){
-            const blockNumber = await this.typedOracle.getBlockNumber();
-            await this.typedOracle.commitState();
-            this.typedOracle.setBlockNumber(blockNumber + 1);
+            const blockNumber = await this.txe.utilityGetBlockNumber();
+            await this.txe.commitState();
+            this.txe.setBlockNumber(blockNumber + 1);
         }
         return toForeignCallResult([]);
     }
-    advanceTimestampBy(duration) {
+    txeAdvanceTimestampBy(duration) {
         const durationBigInt = fromSingle(duration).toBigInt();
         this.logger.debug(`time traveling ${durationBigInt} seconds`);
-        this.typedOracle.advanceTimestampBy(durationBigInt);
+        this.txe.txeAdvanceTimestampBy(durationBigInt);
         return toForeignCallResult([]);
     }
-    setContractAddress(address) {
+    txeSetContractAddress(address) {
         const typedAddress = addressFromSingle(address);
-        this.typedOracle.setContractAddress(typedAddress);
+        this.txe.txeSetContractAddress(typedAddress);
         return toForeignCallResult([]);
     }
-    async deriveKeys(secret) {
-        const keys = await this.typedOracle.deriveKeys(fromSingle(secret));
-        return toForeignCallResult(keys.publicKeys.toFields().map(toSingle));
-    }
-    async deploy(artifact, instance, secret) {
+    async txeDeploy(artifact, instance, secret) {
         // Emit deployment nullifier
-        await this.typedOracle.noteCache.nullifierCreated(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), instance.address.toField());
+        await this.txe.noteCache.nullifierCreated(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), instance.address.toField());
+        // Make sure the deployment nullifier gets included in a tx in a block
+        const blockNumber = await this.txe.utilityGetBlockNumber();
+        await this.txe.commitState();
+        this.txe.setBlockNumber(blockNumber + 1);
         if (!fromSingle(secret).equals(Fr.ZERO)) {
-            await this.addAccount(artifact, instance, secret);
+            await this.txeAddAccount(artifact, instance, secret);
         } else {
-            await this.typedOracle.addContractInstance(instance);
-            await this.typedOracle.addContractArtifact(instance.currentContractClassId, artifact);
+            await this.txe.addContractInstance(instance);
+            await this.txe.addContractArtifact(instance.currentContractClassId, artifact);
             this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
         }
         return toForeignCallResult([
@@ -81,28 +129,14 @@ export class TXEService {
             ])
         ]);
     }
-    async directStorageWrite(contractAddress, startStorageSlot, values) {
-        const startStorageSlotFr = fromSingle(startStorageSlot);
-        const valuesFr = fromArray(values);
-        const contractAddressFr = addressFromSingle(contractAddress);
-        const publicDataWrites = await Promise.all(valuesFr.map(async (value, i)=>{
-            const storageSlot = startStorageSlotFr.add(new Fr(i));
-            this.logger.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${value}`);
-            return new PublicDataWrite(await computePublicDataTreeLeafSlot(contractAddressFr, storageSlot), value);
-        }));
-        await this.typedOracle.addPublicDataWrites(publicDataWrites);
-        return toForeignCallResult([
-            toArray(publicDataWrites.map((write)=>write.value))
-        ]);
-    }
-    async createAccount(secret) {
-        const keyStore = this.typedOracle.getKeyStore();
+    async txeCreateAccount(secret) {
+        const keyStore = this.txe.getKeyStore();
         const secretFr = fromSingle(secret);
         // This is a footgun !
         const completeAddress = await keyStore.addAccount(secretFr, secretFr);
-        const accountDataProvider = this.typedOracle.getAccountDataProvider();
+        const accountDataProvider = this.txe.getAccountDataProvider();
         await accountDataProvider.setAccount(completeAddress.address, completeAddress);
-        const addressDataProvider = this.typedOracle.getAddressDataProvider();
+        const addressDataProvider = this.txe.getAddressDataProvider();
         await addressDataProvider.addCompleteAddress(completeAddress);
         this.logger.debug(`Created account ${completeAddress.address}`);
         return toForeignCallResult([
@@ -110,15 +144,15 @@ export class TXEService {
             ...completeAddress.publicKeys.toFields().map(toSingle)
         ]);
     }
-    async addAccount(artifact, instance, secret) {
+    async txeAddAccount(artifact, instance, secret) {
         this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
-        await this.typedOracle.addContractInstance(instance);
-        await this.typedOracle.addContractArtifact(instance.currentContractClassId, artifact);
-        const keyStore = this.typedOracle.getKeyStore();
+        await this.txe.addContractInstance(instance);
+        await this.txe.addContractArtifact(instance.currentContractClassId, artifact);
+        const keyStore = this.txe.getKeyStore();
         const completeAddress = await keyStore.addAccount(fromSingle(secret), await computePartialAddress(instance));
-        const accountDataProvider = this.typedOracle.getAccountDataProvider();
+        const accountDataProvider = this.txe.getAccountDataProvider();
         await accountDataProvider.setAccount(completeAddress.address, completeAddress);
-        const addressDataProvider = this.typedOracle.getAddressDataProvider();
+        const addressDataProvider = this.txe.getAddressDataProvider();
         await addressDataProvider.addCompleteAddress(completeAddress);
         this.logger.debug(`Created account ${completeAddress.address}`);
         return toForeignCallResult([
@@ -126,190 +160,150 @@ export class TXEService {
             ...completeAddress.publicKeys.toFields().map(toSingle)
         ]);
     }
-    getSideEffectsCounter() {
-        const counter = this.typedOracle.getSideEffectsCounter();
-        return toForeignCallResult([
-            toSingle(new Fr(counter))
-        ]);
-    }
-    async addAuthWitness(address, messageHash) {
-        await this.typedOracle.addAuthWitness(addressFromSingle(address), fromSingle(messageHash));
-        return toForeignCallResult([]);
-    }
-    async assertPublicCallFails(address, functionSelector, _length, args) {
-        const parsedAddress = addressFromSingle(address);
-        const parsedSelector = fromSingle(functionSelector);
-        const extendedArgs = [
-            parsedSelector,
-            ...fromArray(args)
-        ];
-        const result = await this.typedOracle.avmOpcodeCall(parsedAddress, extendedArgs, false);
-        if (result.revertCode.isOK()) {
-            throw new ExpectedFailureError('Public call did not revert');
-        }
-        return toForeignCallResult([]);
-    }
-    async assertPrivateCallFails(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
-        try {
-            await this.typedOracle.callPrivateFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-            throw new ExpectedFailureError('Private call did not fail');
-        } catch (e) {
-            if (e instanceof ExpectedFailureError) {
-                throw e;
-            }
-        }
+    async txeAddAuthWitness(address, messageHash) {
+        await this.txe.txeAddAuthWitness(addressFromSingle(address), fromSingle(messageHash));
         return toForeignCallResult([]);
     }
     // PXE oracles
-    getRandomField() {
-        if (!this.oraclesEnabled) {
+    utilityGetRandomField() {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         return toForeignCallResult([
-            toSingle(this.typedOracle.getRandomField())
+            toSingle(this.txe.utilityGetRandomField())
         ]);
     }
-    async getContractAddress() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+    async utilityGetContractAddress() {
+        if (this.contextChecksEnabled && this.context != 0 && this.context != 3 && this.context != 1) {
+            throw new Error(`Attempted to call utilityGetContractAddress while in context ${TXEContext[this.context]}`);
         }
-        const contractAddress = await this.typedOracle.getContractAddress();
+        const contractAddress = await this.txe.utilityGetContractAddress();
         return toForeignCallResult([
             toSingle(contractAddress.toField())
         ]);
     }
-    async getBlockNumber() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+    async utilityGetBlockNumber() {
+        if (this.contextChecksEnabled && this.context != 0 && this.context != 3) {
+            throw new Error(`Attempted to call utilityGetBlockNumber while in context ${TXEContext[this.context]}`);
         }
-        const blockNumber = await this.typedOracle.getBlockNumber();
+        const blockNumber = await this.txe.utilityGetBlockNumber();
         return toForeignCallResult([
             toSingle(new Fr(blockNumber))
         ]);
     }
-    async getTimestamp() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+    // seems to be used to mean the timestamp of the last mined block in txe (but that's not what is done here)
+    async utilityGetTimestamp() {
+        if (this.contextChecksEnabled && this.context != 0 && this.context != 3) {
+            throw new Error(`Attempted to call utilityGetTimestamp while in context ${TXEContext[this.context]}`);
         }
-        const timestamp = await this.typedOracle.getTimestamp();
+        const timestamp = await this.txe.utilityGetTimestamp();
+        return toForeignCallResult([
+            toSingle(new Fr(timestamp))
+        ]);
+    }
+    async txeGetLastBlockTimestamp() {
+        if (this.contextChecksEnabled && this.context != 0) {
+            throw new Error(`Attempted to call txeGetLastBlockTimestamp while in context ${TXEContext[this.context]}`);
+        }
+        const timestamp = await this.txe.txeGetLastBlockTimestamp();
         return toForeignCallResult([
             toSingle(new Fr(timestamp))
         ]);
     }
     // Since the argument is a slice, noir automatically adds a length field to oracle call.
-    storeInExecutionCache(_length, values, hash) {
-        if (!this.oraclesEnabled) {
+    privateStoreInExecutionCache(_length, values, hash) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        this.typedOracle.storeInExecutionCache(fromArray(values), fromSingle(hash));
+        this.txe.privateStoreInExecutionCache(fromArray(values), fromSingle(hash));
         return toForeignCallResult([]);
     }
-    async loadFromExecutionCache(hash) {
-        if (!this.oraclesEnabled) {
+    async privateLoadFromExecutionCache(hash) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const returns = await this.typedOracle.loadFromExecutionCache(fromSingle(hash));
+        const returns = await this.txe.privateLoadFromExecutionCache(fromSingle(hash));
         return toForeignCallResult([
             toArray(returns)
         ]);
     }
     // Since the argument is a slice, noir automatically adds a length field to oracle call.
-    debugLog(message, _length, fields) {
+    utilityDebugLog(message, _length, fields) {
         const messageStr = fromArray(message).map((field)=>String.fromCharCode(field.toNumber())).join('');
         const fieldsFr = fromArray(fields);
-        this.typedOracle.debugLog(messageStr, fieldsFr);
+        this.txe.utilityDebugLog(messageStr, fieldsFr);
         return toForeignCallResult([]);
     }
-    async storageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
-        const values = await this.typedOracle.storageRead(addressFromSingle(contractAddress), fromSingle(startStorageSlot), fromSingle(blockNumber).toNumber(), fromSingle(numberOfElements).toNumber());
+    async utilityStorageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
+        const values = await this.txe.utilityStorageRead(addressFromSingle(contractAddress), fromSingle(startStorageSlot), fromSingle(blockNumber).toNumber(), fromSingle(numberOfElements).toNumber());
         return toForeignCallResult([
             toArray(values)
         ]);
     }
-    async storageWrite(startStorageSlot, values) {
-        const newValues = await this.typedOracle.storageWrite(fromSingle(startStorageSlot), fromArray(values));
-        return toForeignCallResult([
-            toArray(newValues)
-        ]);
-    }
-    async getPublicDataWitness(blockNumber, leafSlot) {
-        if (!this.oraclesEnabled) {
+    async utilityGetPublicDataWitness(blockNumber, leafSlot) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
         const parsedLeafSlot = fromSingle(leafSlot);
-        const witness = await this.typedOracle.getPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
+        const witness = await this.txe.utilityGetPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
         if (!witness) {
             throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
         }
         return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async getNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, maxNotes, packedRetrievedNoteLength) {
-        if (!this.oraclesEnabled) {
+    async utilityGetNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, maxNotes, packedRetrievedNoteLength) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const noteDatas = await this.typedOracle.getNotes(fromSingle(storageSlot), fromSingle(numSelects).toNumber(), fromArray(selectByIndexes).map((fr)=>fr.toNumber()), fromArray(selectByOffsets).map((fr)=>fr.toNumber()), fromArray(selectByLengths).map((fr)=>fr.toNumber()), fromArray(selectValues), fromArray(selectComparators).map((fr)=>fr.toNumber()), fromArray(sortByIndexes).map((fr)=>fr.toNumber()), fromArray(sortByOffsets).map((fr)=>fr.toNumber()), fromArray(sortByLengths).map((fr)=>fr.toNumber()), fromArray(sortOrder).map((fr)=>fr.toNumber()), fromSingle(limit).toNumber(), fromSingle(offset).toNumber(), fromSingle(status).toNumber());
+        const noteDatas = await this.txe.utilityGetNotes(fromSingle(storageSlot), fromSingle(numSelects).toNumber(), fromArray(selectByIndexes).map((fr)=>fr.toNumber()), fromArray(selectByOffsets).map((fr)=>fr.toNumber()), fromArray(selectByLengths).map((fr)=>fr.toNumber()), fromArray(selectValues), fromArray(selectComparators).map((fr)=>fr.toNumber()), fromArray(sortByIndexes).map((fr)=>fr.toNumber()), fromArray(sortByOffsets).map((fr)=>fr.toNumber()), fromArray(sortByLengths).map((fr)=>fr.toNumber()), fromArray(sortOrder).map((fr)=>fr.toNumber()), fromSingle(limit).toNumber(), fromSingle(offset).toNumber(), fromSingle(status).toNumber());
         if (noteDatas.length > 0) {
             const noteLength = noteDatas[0].note.items.length;
             if (!noteDatas.every(({ note })=>noteLength === note.items.length)) {
                 throw new Error('Notes should all be the same length.');
             }
         }
-        // The expected return type is a BoundedVec<[Field; packedRetrievedNoteLength], maxNotes> where each
-        // array is structured as [contract_address, note_nonce, nonzero_note_hash_counter, ...packed_note].
-        const returnDataAsArrayOfArrays = noteDatas.map(({ contractAddress, noteNonce, index, note })=>{
-            // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
-            const noteIsTransient = index === undefined;
-            const nonzeroNoteHashCounter = noteIsTransient ? true : false;
-            // If you change the array on the next line you have to change the `unpack_retrieved_note` function in
-            // `aztec/src/note/retrieved_note.nr`
-            return [
-                contractAddress,
-                noteNonce,
-                nonzeroNoteHashCounter,
-                ...note.items
-            ];
-        });
+        const returnDataAsArrayOfArrays = noteDatas.map(packAsRetrievedNote);
         // 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, fromSingle(maxNotes).toNumber(), fromSingle(packedRetrievedNoteLength).toNumber()));
     }
-    notifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter) {
-        if (!this.oraclesEnabled) {
+    privateNotifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        this.typedOracle.notifyCreatedNote(fromSingle(storageSlot), NoteSelector.fromField(fromSingle(noteTypeId)), fromArray(note), fromSingle(noteHash), fromSingle(counter).toNumber());
+        this.txe.privateNotifyCreatedNote(fromSingle(storageSlot), NoteSelector.fromField(fromSingle(noteTypeId)), fromArray(note), fromSingle(noteHash), fromSingle(counter).toNumber());
         return toForeignCallResult([]);
     }
-    async notifyNullifiedNote(innerNullifier, noteHash, counter) {
-        if (!this.oraclesEnabled) {
+    async privateNotifyNullifiedNote(innerNullifier, noteHash, counter) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.notifyNullifiedNote(fromSingle(innerNullifier), fromSingle(noteHash), fromSingle(counter).toNumber());
+        await this.txe.privateNotifyNullifiedNote(fromSingle(innerNullifier), fromSingle(noteHash), fromSingle(counter).toNumber());
         return toForeignCallResult([]);
     }
-    async notifyCreatedNullifier(innerNullifier) {
-        if (!this.oraclesEnabled) {
+    async privateNotifyCreatedNullifier(innerNullifier) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.notifyCreatedNullifier(fromSingle(innerNullifier));
+        await this.txe.privateNotifyCreatedNullifier(fromSingle(innerNullifier));
         return toForeignCallResult([]);
     }
-    async checkNullifierExists(innerNullifier) {
-        if (!this.oraclesEnabled) {
+    async utilityCheckNullifierExists(innerNullifier) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const exists = await this.typedOracle.checkNullifierExists(fromSingle(innerNullifier));
+        const exists = await this.txe.utilityCheckNullifierExists(fromSingle(innerNullifier));
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
-    async getContractInstance(address) {
-        if (!this.oraclesEnabled) {
+    async utilityGetContractInstance(address) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
+        const instance = await this.txe.utilityGetContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             instance.salt,
             instance.deployer.toField(),
@@ -318,12 +312,12 @@ export class TXEService {
             ...instance.publicKeys.toFields()
         ].map(toSingle));
     }
-    async getPublicKeysAndPartialAddress(address) {
-        if (!this.oraclesEnabled) {
+    async utilityGetPublicKeysAndPartialAddress(address) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         const parsedAddress = addressFromSingle(address);
-        const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
+        const { publicKeys, partialAddress } = await this.txe.utilityGetCompleteAddress(parsedAddress);
         return toForeignCallResult([
             toArray([
                 ...publicKeys.toFields(),
@@ -331,42 +325,33 @@ export class TXEService {
             ])
         ]);
     }
-    async getKeyValidationRequest(pkMHash) {
-        if (!this.oraclesEnabled) {
+    async utilityGetKeyValidationRequest(pkMHash) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const keyValidationRequest = await this.typedOracle.getKeyValidationRequest(fromSingle(pkMHash));
+        const keyValidationRequest = await this.txe.utilityGetKeyValidationRequest(fromSingle(pkMHash));
         return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
     }
-    async callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        const result = await this.typedOracle.callPrivateFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-        return toForeignCallResult([
-            toArray([
-                result.endSideEffectCounter,
-                result.returnsHash
-            ])
-        ]);
+    privateCallPrivateFunction(_targetContractAddress, _functionSelector, _argsHash, _sideEffectCounter, _isStaticCall) {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::private_context`, use `private_call` instead');
     }
-    async getNullifierMembershipWitness(blockNumber, nullifier) {
-        if (!this.oraclesEnabled) {
+    async utilityGetNullifierMembershipWitness(blockNumber, nullifier) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
-        const witness = await this.typedOracle.getNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
+        const witness = await this.txe.utilityGetNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
         if (!witness) {
             throw new Error(`Nullifier membership witness not found at block ${parsedBlockNumber}.`);
         }
         return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async getAuthWitness(messageHash) {
-        if (!this.oraclesEnabled) {
+    async utilityGetAuthWitness(messageHash) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         const parsedMessageHash = fromSingle(messageHash);
-        const authWitness = await this.typedOracle.getAuthWitness(parsedMessageHash);
+        const authWitness = await this.txe.utilityGetAuthWitness(parsedMessageHash);
         if (!authWitness) {
             throw new Error(`Auth witness not found for message hash ${parsedMessageHash}.`);
         }
@@ -374,61 +359,49 @@ export class TXEService {
             toArray(authWitness)
         ]);
     }
-    async notifyEnqueuedPublicFunctionCall(targetContractAddress, calldataHash, sideEffectCounter, isStaticCall) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        await this.typedOracle.notifyEnqueuedPublicFunctionCall(addressFromSingle(targetContractAddress), fromSingle(calldataHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-        return toForeignCallResult([]);
+    privateNotifyEnqueuedPublicFunctionCall(_targetContractAddress, _calldataHash, _sideEffectCounter, _isStaticCall) {
+        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
     }
-    async notifySetPublicTeardownFunctionCall(targetContractAddress, calldataHash, sideEffectCounter, isStaticCall) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        await this.typedOracle.notifySetPublicTeardownFunctionCall(addressFromSingle(targetContractAddress), fromSingle(calldataHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-        return toForeignCallResult([]);
+    privateNotifySetPublicTeardownFunctionCall(_targetContractAddress, _calldataHash, _sideEffectCounter, _isStaticCall) {
+        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
     }
-    async notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        await this.typedOracle.notifySetMinRevertibleSideEffectCounter(fromSingle(minRevertibleSideEffectCounter).toNumber());
-        return toForeignCallResult([]);
+    privateNotifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter) {
+        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
     }
-    async getChainId() {
-        if (!this.oraclesEnabled) {
+    async utilityGetChainId() {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         return toForeignCallResult([
-            toSingle(await this.typedOracle.getChainId())
+            toSingle(await this.txe.utilityGetChainId())
         ]);
     }
-    async getVersion() {
-        if (!this.oraclesEnabled) {
+    async utilityGetVersion() {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         return toForeignCallResult([
-            toSingle(await this.typedOracle.getVersion())
+            toSingle(await this.txe.utilityGetVersion())
         ]);
     }
-    async getBlockHeader(blockNumber) {
-        if (!this.oraclesEnabled) {
+    async utilityGetBlockHeader(blockNumber) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const header = await this.typedOracle.getBlockHeader(fromSingle(blockNumber).toNumber());
+        const header = await this.txe.utilityGetBlockHeader(fromSingle(blockNumber).toNumber());
         if (!header) {
             throw new Error(`Block header not found for block ${blockNumber}.`);
         }
         return toForeignCallResult(header.toFields().map(toSingle));
     }
-    async getMembershipWitness(blockNumber, treeId, leafValue) {
-        if (!this.oraclesEnabled) {
+    async utilityGetMembershipWitness(blockNumber, treeId, leafValue) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
         const parsedTreeId = fromSingle(treeId).toNumber();
         const parsedLeafValue = fromSingle(leafValue);
-        const witness = await this.typedOracle.getMembershipWitness(parsedBlockNumber, parsedTreeId, parsedLeafValue);
+        const witness = await this.txe.utilityGetMembershipWitness(parsedBlockNumber, parsedTreeId, parsedLeafValue);
         if (!witness) {
             throw new Error(`Membership witness in tree ${MerkleTreeId[parsedTreeId]} not found for value ${parsedLeafValue} at block ${parsedBlockNumber}.`);
         }
@@ -437,57 +410,57 @@ export class TXEService {
             toArray(witness.slice(1))
         ]);
     }
-    async getLowNullifierMembershipWitness(blockNumber, nullifier) {
-        if (!this.oraclesEnabled) {
+    async utilityGetLowNullifierMembershipWitness(blockNumber, nullifier) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
-        const witness = await this.typedOracle.getLowNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
+        const witness = await this.txe.utilityGetLowNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
         if (!witness) {
             throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${parsedBlockNumber}.`);
         }
         return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async getIndexedTaggingSecretAsSender(sender, recipient) {
-        if (!this.oraclesEnabled) {
+    async utilityGetIndexedTaggingSecretAsSender(sender, recipient) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const secret = await this.typedOracle.getIndexedTaggingSecretAsSender(AztecAddress.fromField(fromSingle(sender)), AztecAddress.fromField(fromSingle(recipient)));
+        const secret = await this.txe.utilityGetIndexedTaggingSecretAsSender(AztecAddress.fromField(fromSingle(sender)), AztecAddress.fromField(fromSingle(recipient)));
         return toForeignCallResult(secret.toFields().map(toSingle));
     }
-    async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
-        if (!this.oraclesEnabled) {
+    async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.fetchTaggedLogs(fromSingle(pendingTaggedLogArrayBaseSlot));
+        await this.txe.utilityFetchTaggedLogs(fromSingle(pendingTaggedLogArrayBaseSlot));
         return toForeignCallResult([]);
     }
-    async validateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
-        if (!this.oraclesEnabled) {
+    async utilityValidateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.validateEnqueuedNotesAndEvents(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(noteValidationRequestsArrayBaseSlot), fromSingle(eventValidationRequestsArrayBaseSlot));
+        await this.txe.utilityValidateEnqueuedNotesAndEvents(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(noteValidationRequestsArrayBaseSlot), fromSingle(eventValidationRequestsArrayBaseSlot));
         return toForeignCallResult([]);
     }
-    async bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
-        if (!this.oraclesEnabled) {
+    async utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.bulkRetrieveLogs(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(logRetrievalRequestsArrayBaseSlot), fromSingle(logRetrievalResponsesArrayBaseSlot));
+        await this.txe.utilityBulkRetrieveLogs(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(logRetrievalRequestsArrayBaseSlot), fromSingle(logRetrievalResponsesArrayBaseSlot));
         return toForeignCallResult([]);
     }
-    async storeCapsule(contractAddress, slot, capsule) {
-        if (!this.oraclesEnabled) {
+    async utilityStoreCapsule(contractAddress, slot, capsule) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.storeCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot), fromArray(capsule));
+        await this.txe.utilityStoreCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot), fromArray(capsule));
         return toForeignCallResult([]);
     }
-    async loadCapsule(contractAddress, slot, tSize) {
-        if (!this.oraclesEnabled) {
+    async utilityLoadCapsule(contractAddress, slot, tSize) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const values = await this.typedOracle.loadCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
+        const values = await this.txe.utilityLoadCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(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) {
@@ -504,39 +477,39 @@ export class TXEService {
             ]);
         }
     }
-    async deleteCapsule(contractAddress, slot) {
-        if (!this.oraclesEnabled) {
+    async utilityDeleteCapsule(contractAddress, slot) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.deleteCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
+        await this.txe.utilityDeleteCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
         return toForeignCallResult([]);
     }
-    async copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
-        if (!this.oraclesEnabled) {
+    async utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        await this.typedOracle.copyCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(srcSlot), fromSingle(dstSlot), fromSingle(numEntries).toNumber());
+        await this.txe.utilityCopyCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(srcSlot), fromSingle(dstSlot), fromSingle(numEntries).toNumber());
         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 aes128Decrypt(ciphertextBVecStorage, ciphertextLength, iv, symKey) {
-        if (!this.oraclesEnabled) {
+    async utilityAes128Decrypt(ciphertextBVecStorage, ciphertextLength, iv, symKey) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
         const ciphertext = fromUintBoundedVec(ciphertextBVecStorage, ciphertextLength, 8);
         const ivBuffer = fromUintArray(iv, 8);
         const symKeyBuffer = fromUintArray(symKey, 8);
-        const plaintextBuffer = await this.typedOracle.aes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
+        const plaintextBuffer = await this.txe.utilityAes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
         return toForeignCallResult(arrayToBoundedVec(bufferToU8Array(plaintextBuffer), ciphertextBVecStorage.length));
     }
-    async getSharedSecret(address, ephPKField0, ephPKField1, ephPKField2) {
-        if (!this.oraclesEnabled) {
+    async utilityGetSharedSecret(address, ephPKField0, ephPKField1, ephPKField2) {
+        if (this.contextChecksEnabled && this.context == 0) {
             throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
         }
-        const secret = await this.typedOracle.getSharedSecret(AztecAddress.fromField(fromSingle(address)), Point.fromFields([
+        const secret = await this.txe.utilityGetSharedSecret(AztecAddress.fromField(fromSingle(address)), Point.fromFields([
             fromSingle(ephPKField0),
             fromSingle(ephPKField1),
             fromSingle(ephPKField2)
@@ -544,44 +517,39 @@ export class TXEService {
         return toForeignCallResult(secret.toFields().map(toSingle));
     }
     emitOffchainEffect(_data) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        // Offchain effects are currently discarded in the TXE tests.
-        // TODO: Expose this to the tests.
-        return toForeignCallResult([]);
+        throw new Error('Offchain effects are not yet supported in the TestEnvironment');
     }
     // AVM opcodes
     avmOpcodeEmitUnencryptedLog(_message) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeEmitUnencryptedLog oracle while in context ${TXEContext[this.context]}`);
         }
         // TODO(#8811): Implement
         return toForeignCallResult([]);
     }
     async avmOpcodeStorageRead(slot) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeStorageRead oracle while in context ${TXEContext[this.context]}`);
         }
-        const value = (await this.typedOracle.avmOpcodeStorageRead(fromSingle(slot))).value;
+        const value = (await this.txe.avmOpcodeStorageRead(fromSingle(slot))).value;
         return toForeignCallResult([
             toSingle(new Fr(value))
         ]);
     }
     async avmOpcodeStorageWrite(slot, value) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeStorageWrite oracle while in context ${TXEContext[this.context]}`);
         }
-        await this.typedOracle.storageWrite(fromSingle(slot), [
+        await this.txe.storageWrite(fromSingle(slot), [
             fromSingle(value)
         ]);
         return toForeignCallResult([]);
     }
     async avmOpcodeGetContractInstanceDeployer(address) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeGetContractInstanceDeployer oracle while in context ${TXEContext[this.context]}`);
         }
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
+        const instance = await this.txe.utilityGetContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             toSingle(instance.deployer),
             // AVM requires an extra boolean indicating the instance was found
@@ -589,10 +557,10 @@ export class TXEService {
         ]);
     }
     async avmOpcodeGetContractInstanceClassId(address) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeGetContractInstanceClassId oracle while in context ${TXEContext[this.context]}`);
         }
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
+        const instance = await this.txe.utilityGetContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             toSingle(instance.currentContractClassId),
             // AVM requires an extra boolean indicating the instance was found
@@ -600,10 +568,10 @@ export class TXEService {
         ]);
     }
     async avmOpcodeGetContractInstanceInitializationHash(address) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeGetContractInstanceInitializationHash oracle while in context ${TXEContext[this.context]}`);
         }
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
+        const instance = await this.txe.utilityGetContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             toSingle(instance.initializationHash),
             // AVM requires an extra boolean indicating the instance was found
@@ -611,181 +579,157 @@ export class TXEService {
         ]);
     }
     avmOpcodeSender() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeSender oracle while in context ${TXEContext[this.context]}`);
         }
-        const sender = this.typedOracle.getMsgSender();
+        const sender = this.txe.getMsgSender();
         return toForeignCallResult([
             toSingle(sender)
         ]);
     }
     async avmOpcodeEmitNullifier(nullifier) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeEmitNullifier oracle while in context ${TXEContext[this.context]}`);
         }
-        await this.typedOracle.avmOpcodeEmitNullifier(fromSingle(nullifier));
+        await this.txe.avmOpcodeEmitNullifier(fromSingle(nullifier));
         return toForeignCallResult([]);
     }
     async avmOpcodeEmitNoteHash(noteHash) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeEmitNoteHash oracle while in context ${TXEContext[this.context]}`);
         }
-        await this.typedOracle.avmOpcodeEmitNoteHash(fromSingle(noteHash));
+        await this.txe.avmOpcodeEmitNoteHash(fromSingle(noteHash));
         return toForeignCallResult([]);
     }
     async avmOpcodeNullifierExists(innerNullifier, targetAddress) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeNullifierExists oracle while in context ${TXEContext[this.context]}`);
         }
-        const exists = await this.typedOracle.avmOpcodeNullifierExists(fromSingle(innerNullifier), AztecAddress.fromField(fromSingle(targetAddress)));
+        const exists = await this.txe.avmOpcodeNullifierExists(fromSingle(innerNullifier), AztecAddress.fromField(fromSingle(targetAddress)));
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
     async avmOpcodeAddress() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeAddress oracle while in context ${TXEContext[this.context]}`);
         }
-        const contractAddress = await this.typedOracle.getContractAddress();
+        const contractAddress = await this.txe.utilityGetContractAddress();
         return toForeignCallResult([
             toSingle(contractAddress.toField())
         ]);
     }
     async avmOpcodeBlockNumber() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeBlockNumber oracle while in context ${TXEContext[this.context]}`);
         }
-        const blockNumber = await this.typedOracle.getBlockNumber();
+        const blockNumber = await this.txe.utilityGetBlockNumber();
         return toForeignCallResult([
             toSingle(new Fr(blockNumber))
         ]);
     }
     async avmOpcodeTimestamp() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeTimestamp oracle while in context ${TXEContext[this.context]}`);
         }
-        const timestamp = await this.typedOracle.getTimestamp();
+        const timestamp = await this.txe.utilityGetTimestamp();
         return toForeignCallResult([
             toSingle(new Fr(timestamp))
         ]);
     }
     avmOpcodeIsStaticCall() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeIsStaticCall oracle while in context ${TXEContext[this.context]}`);
         }
-        const isStaticCall = this.typedOracle.getIsStaticCall();
+        // TestEnvironment::public_context is always static
+        const isStaticCall = true;
         return toForeignCallResult([
             toSingle(new Fr(isStaticCall ? 1 : 0))
         ]);
     }
     async avmOpcodeChainId() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeChainId oracle while in context ${TXEContext[this.context]}`);
         }
-        const chainId = await this.typedOracle.getChainId();
+        const chainId = await this.txe.utilityGetChainId();
         return toForeignCallResult([
             toSingle(chainId)
         ]);
     }
     async avmOpcodeVersion() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        if (this.contextChecksEnabled && this.context != 2) {
+            throw new Error(`Attempted to call the avmOpcodeVersion oracle while in context ${TXEContext[this.context]}`);
         }
-        const version = await this.typedOracle.getVersion();
+        const version = await this.txe.utilityGetVersion();
         return toForeignCallResult([
             toSingle(version)
         ]);
     }
     avmOpcodeReturndataSize() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        const size = this.typedOracle.avmOpcodeReturndataSize();
-        return toForeignCallResult([
-            toSingle(new Fr(size))
-        ]);
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    avmOpcodeReturndataCopy(rdOffset, copySize) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        const returndata = this.typedOracle.avmOpcodeReturndataCopy(fromSingle(rdOffset).toNumber(), fromSingle(copySize).toNumber());
-        // This is a slice, so we need to return the length as well.
-        return toForeignCallResult([
-            toSingle(new Fr(returndata.length)),
-            toArray(returndata)
-        ]);
+    avmOpcodeReturndataCopy(_rdOffset, _copySize) {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    async avmOpcodeCall(_l2Gas, _daGas, address, _length, args) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        const result = await this.typedOracle.avmOpcodeCall(addressFromSingle(address), fromArray(args), /* isStaticCall */ false);
-        // Poor man's revert handling
-        if (!result.revertCode.isOK()) {
-            if (result.revertReason && result.revertReason instanceof SimulationError) {
-                await enrichPublicSimulationError(result.revertReason, this.typedOracle.getContractDataProvider(), this.logger);
-                throw new Error(result.revertReason.message);
-            } else {
-                throw new Error(`Public function call reverted: ${result.revertReason}`);
-            }
-        }
-        return toForeignCallResult([]);
+    avmOpcodeCall(_l2Gas, _daGas, _address, _length, _args) {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    async avmOpcodeStaticCall(_l2Gas, _daGas, address, _length, args) {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        const result = await this.typedOracle.avmOpcodeCall(addressFromSingle(address), fromArray(args), /* isStaticCall */ true);
-        // Poor man's revert handling
-        if (!result.revertCode.isOK()) {
-            if (result.revertReason && result.revertReason instanceof SimulationError) {
-                await enrichPublicSimulationError(result.revertReason, this.typedOracle.getContractDataProvider(), this.logger);
-                throw new Error(result.revertReason.message);
-            } else {
-                throw new Error(`Public function call reverted: ${result.revertReason}`);
-            }
-        }
-        return toForeignCallResult([]);
+    avmOpcodeStaticCall(_l2Gas, _daGas, _address, _length, _args) {
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
     avmOpcodeSuccessCopy() {
-        if (!this.oraclesEnabled) {
-            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
-        }
-        const success = this.typedOracle.avmOpcodeSuccessCopy();
-        return toForeignCallResult([
-            toSingle(new Fr(success))
-        ]);
+        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
     }
-    async privateCallNewFlow(from, targetContractAddress, functionSelector, _argsLength, args, argsHash, isStaticCall) {
-        const result = await this.typedOracle.privateCallNewFlow(addressFromSingle(from), addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromArray(args), fromSingle(argsHash), fromSingle(isStaticCall).toBool());
+    async txePrivateCallNewFlow(from, targetContractAddress, functionSelector, _argsLength, args, argsHash, isStaticCall) {
+        const result = await this.txe.txePrivateCallNewFlow(addressFromSingle(from), addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromArray(args), fromSingle(argsHash), fromSingle(isStaticCall).toBool());
         return toForeignCallResult([
             toArray([
                 result.endSideEffectCounter,
                 result.returnsHash,
-                result.txHash
+                result.txHash.hash
             ])
         ]);
     }
-    disableOracles() {
-        this.oraclesEnabled = false;
-    }
-    enableOracles() {
-        this.oraclesEnabled = true;
-    }
     async simulateUtilityFunction(targetContractAddress, functionSelector, argsHash) {
-        const result = await this.typedOracle.simulateUtilityFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash));
+        const result = await this.txe.simulateUtilityFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash));
         return toForeignCallResult([
             toSingle(result)
         ]);
     }
-    async publicCallNewFlow(from, address, _length, calldata, isStaticCall) {
-        const result = await this.typedOracle.publicCallNewFlow(addressFromSingle(from), addressFromSingle(address), fromArray(calldata), fromSingle(isStaticCall).toBool());
+    async txePublicCallNewFlow(from, address, _length, calldata, isStaticCall) {
+        const result = await this.txe.txePublicCallNewFlow(addressFromSingle(from), addressFromSingle(address), fromArray(calldata), fromSingle(isStaticCall).toBool());
         return toForeignCallResult([
             toArray([
                 result.returnsHash,
-                result.txHash
+                result.txHash.hash
             ])
         ]);
     }
+    async privateGetSenderForTags() {
+        if (this.contextChecksEnabled && this.context == 0) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
+        const sender = await this.txe.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(senderForTags) {
+        if (this.contextChecksEnabled && this.context == 0) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
+        await this.txe.privateSetSenderForTags(AztecAddress.fromField(fromSingle(senderForTags)));
+        return toForeignCallResult([]);
+    }
 }