@aztec/txe 2.0.0-nightly.20250903 → 2.0.0-rc.2

package/dest/txe_service/txe_service.js

@@ -5,37 +5,56 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } from '../util/encoding.js';
 export class TXEService {
-    executor;
-    constructor(executor){
-        this.executor = executor;
+    stateHandler;
+    oracleHandler;
+    /**
+   * Create a new instance of `TXEService` 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;
+    }
+    // TXE session state transition functions - these get handled by the state handler
+    async txeSetTopLevelTXEContext() {
+        await this.stateHandler.setTopLevelContext();
+        return toForeignCallResult([]);
+    }
+    async txeSetPrivateTXEContext(foreignContractAddressIsSome, foreignContractAddressValue, foreignHistoricalBlockNumberIsSome, foreignHistoricalBlockNumberValue) {
+        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
+        const historicalBlockNumber = fromSingle(foreignHistoricalBlockNumberIsSome).toBool() ? fromSingle(foreignHistoricalBlockNumberValue).toNumber() : undefined;
+        const privateContextInputs = await this.stateHandler.setPrivateContext(contractAddress, historicalBlockNumber);
+        return toForeignCallResult(privateContextInputs.toFields().map(toSingle));
     }
-    setExecutor(executor) {
-        this.executor = executor;
+    async txeSetPublicTXEContext(foreignContractAddressIsSome, foreignContractAddressValue) {
+        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
+        await this.stateHandler.setPublicContext(contractAddress);
+        return toForeignCallResult([]);
     }
-    // Cheatcodes
-    async txeGetPrivateContextInputs(foreignBlockNumberIsSome, foreignBlockNumberValue) {
-        const blockNumber = fromSingle(foreignBlockNumberIsSome).toBool() ? fromSingle(foreignBlockNumberValue).toNumber() : null;
-        const inputs = await this.executor.txeGetPrivateContextInputs(blockNumber);
-        return toForeignCallResult(inputs.toFields().map(toSingle));
+    async txeSetUtilityTXEContext(foreignContractAddressIsSome, foreignContractAddressValue) {
+        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
+        await this.stateHandler.setUtilityContext(contractAddress);
+        return toForeignCallResult([]);
     }
+    // Other oracles - these get handled by the oracle handler
+    // TXE-specific oracles
     async txeAdvanceBlocksBy(foreignBlocks) {
         const blocks = fromSingle(foreignBlocks).toNumber();
-        await this.executor.txeAdvanceBlocksBy(blocks);
+        await this.oracleHandler.txeAdvanceBlocksBy(blocks);
         return toForeignCallResult([]);
     }
     txeAdvanceTimestampBy(foreignDuration) {
         const duration = fromSingle(foreignDuration).toBigInt();
-        this.executor.txeAdvanceTimestampBy(duration);
-        return toForeignCallResult([]);
-    }
-    txeSetContractAddress(foreignAddress) {
-        const address = addressFromSingle(foreignAddress);
-        this.executor.txeSetContractAddress(address);
+        this.oracleHandler.txeAdvanceTimestampBy(duration);
         return toForeignCallResult([]);
     }
     async txeDeploy(artifact, instance, foreignSecret) {
         const secret = fromSingle(foreignSecret);
-        await this.executor.txeDeploy(artifact, instance, secret);
+        await this.oracleHandler.txeDeploy(artifact, instance, secret);
         return toForeignCallResult([
             toArray([
                 instance.salt,
@@ -48,7 +67,7 @@ export class TXEService {
     }
     async txeCreateAccount(foreignSecret) {
         const secret = fromSingle(foreignSecret);
-        const completeAddress = await this.executor.txeCreateAccount(secret);
+        const completeAddress = await this.oracleHandler.txeCreateAccount(secret);
         return toForeignCallResult([
             toSingle(completeAddress.address),
             ...completeAddress.publicKeys.toFields().map(toSingle)
@@ -56,7 +75,7 @@ export class TXEService {
     }
     async txeAddAccount(artifact, instance, foreignSecret) {
         const secret = fromSingle(foreignSecret);
-        const completeAddress = await this.executor.txeAddAccount(artifact, instance, secret);
+        const completeAddress = await this.oracleHandler.txeAddAccount(artifact, instance, secret);
         return toForeignCallResult([
             toSingle(completeAddress.address),
             ...completeAddress.publicKeys.toFields().map(toSingle)
@@ -65,42 +84,42 @@ export class TXEService {
     async txeAddAuthWitness(foreignAddress, foreignMessageHash) {
         const address = addressFromSingle(foreignAddress);
         const messageHash = fromSingle(foreignMessageHash);
-        await this.executor.txeAddAuthWitness(address, messageHash);
+        await this.oracleHandler.txeAddAuthWitness(address, messageHash);
         return toForeignCallResult([]);
     }
     // PXE oracles
     utilityAssertCompatibleOracleVersion(foreignVersion) {
         const version = fromSingle(foreignVersion).toNumber();
-        this.executor.utilityAssertCompatibleOracleVersion(version);
+        this.oracleHandler.utilityAssertCompatibleOracleVersion(version);
         return toForeignCallResult([]);
     }
     utilityGetRandomField() {
-        const randomField = this.executor.utilityGetRandomField();
+        const randomField = this.oracleHandler.utilityGetRandomField();
         return toForeignCallResult([
             toSingle(randomField)
         ]);
     }
     async utilityGetContractAddress() {
-        const contractAddress = await this.executor.utilityGetContractAddress();
+        const contractAddress = await this.oracleHandler.utilityGetContractAddress();
         return toForeignCallResult([
             toSingle(contractAddress.toField())
         ]);
     }
     async utilityGetBlockNumber() {
-        const blockNumber = await this.executor.utilityGetBlockNumber();
+        const blockNumber = await this.oracleHandler.utilityGetBlockNumber();
         return toForeignCallResult([
             toSingle(new Fr(blockNumber))
         ]);
     }
     // 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() {
-        const timestamp = await this.executor.utilityGetTimestamp();
+        const timestamp = await this.oracleHandler.utilityGetTimestamp();
         return toForeignCallResult([
             toSingle(new Fr(timestamp))
         ]);
     }
     async txeGetLastBlockTimestamp() {
-        const timestamp = await this.executor.txeGetLastBlockTimestamp();
+        const timestamp = await this.oracleHandler.txeGetLastBlockTimestamp();
         return toForeignCallResult([
             toSingle(new Fr(timestamp))
         ]);
@@ -109,12 +128,12 @@ export class TXEService {
     privateStoreInExecutionCache(_foreignLength, foreignValues, foreignHash) {
         const values = fromArray(foreignValues);
         const hash = fromSingle(foreignHash);
-        this.executor.privateStoreInExecutionCache(values, hash);
+        this.oracleHandler.privateStoreInExecutionCache(values, hash);
         return toForeignCallResult([]);
     }
     async privateLoadFromExecutionCache(foreignHash) {
         const hash = fromSingle(foreignHash);
-        const returns = await this.executor.privateLoadFromExecutionCache(hash);
+        const returns = await this.oracleHandler.privateLoadFromExecutionCache(hash);
         return toForeignCallResult([
             toArray(returns)
         ]);
@@ -123,7 +142,7 @@ export class TXEService {
     utilityDebugLog(foreignMessage, _foreignLength, foreignFields) {
         const message = fromArray(foreignMessage).map((field)=>String.fromCharCode(field.toNumber())).join('');
         const fields = fromArray(foreignFields);
-        this.executor.utilityDebugLog(message, fields);
+        this.oracleHandler.utilityDebugLog(message, fields);
         return toForeignCallResult([]);
     }
     async utilityStorageRead(foreignContractAddress, foreignStartStorageSlot, foreignBlockNumber, foreignNumberOfElements) {
@@ -131,7 +150,7 @@ export class TXEService {
         const startStorageSlot = fromSingle(foreignStartStorageSlot);
         const blockNumber = fromSingle(foreignBlockNumber).toNumber();
         const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
-        const values = await this.executor.utilityStorageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements);
+        const values = await this.oracleHandler.utilityStorageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements);
         return toForeignCallResult([
             toArray(values)
         ]);
@@ -139,7 +158,7 @@ export class TXEService {
     async utilityGetPublicDataWitness(foreignBlockNumber, foreignLeafSlot) {
         const blockNumber = fromSingle(foreignBlockNumber).toNumber();
         const leafSlot = fromSingle(foreignLeafSlot);
-        const witness = await this.executor.utilityGetPublicDataWitness(blockNumber, leafSlot);
+        const witness = await this.oracleHandler.utilityGetPublicDataWitness(blockNumber, leafSlot);
         if (!witness) {
             throw new Error(`Public data witness not found for slot ${leafSlot} at block ${blockNumber}.`);
         }
@@ -162,7 +181,7 @@ export class TXEService {
         const status = fromSingle(foreignStatus).toNumber();
         const maxNotes = fromSingle(foreignMaxNotes).toNumber();
         const packedRetrievedNoteLength = fromSingle(foreignPackedRetrievedNoteLength).toNumber();
-        const noteDatas = await this.executor.utilityGetNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status);
+        const noteDatas = await this.oracleHandler.utilityGetNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status);
         const returnDataAsArrayOfArrays = noteDatas.map(packAsRetrievedNote);
         // Now we convert each sub-array to an array of ForeignCallSingles
         const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map((subArray)=>subArray.map(toSingle));
@@ -175,31 +194,31 @@ export class TXEService {
         const note = fromArray(foreignNote);
         const noteHash = fromSingle(foreignNoteHash);
         const counter = fromSingle(foreignCounter).toNumber();
-        this.executor.privateNotifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter);
+        this.oracleHandler.privateNotifyCreatedNote(storageSlot, 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.executor.privateNotifyNullifiedNote(innerNullifier, noteHash, counter);
+        await this.oracleHandler.privateNotifyNullifiedNote(innerNullifier, noteHash, counter);
         return toForeignCallResult([]);
     }
     async privateNotifyCreatedNullifier(foreignInnerNullifier) {
         const innerNullifier = fromSingle(foreignInnerNullifier);
-        await this.executor.privateNotifyCreatedNullifier(innerNullifier);
+        await this.oracleHandler.privateNotifyCreatedNullifier(innerNullifier);
         return toForeignCallResult([]);
     }
     async utilityCheckNullifierExists(foreignInnerNullifier) {
         const innerNullifier = fromSingle(foreignInnerNullifier);
-        const exists = await this.executor.utilityCheckNullifierExists(innerNullifier);
+        const exists = await this.oracleHandler.utilityCheckNullifierExists(innerNullifier);
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
     async utilityGetContractInstance(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.executor.utilityGetContractInstance(address);
+        const instance = await this.oracleHandler.utilityGetContractInstance(address);
         return toForeignCallResult([
             instance.salt,
             instance.deployer.toField(),
@@ -210,7 +229,7 @@ export class TXEService {
     }
     async utilityGetPublicKeysAndPartialAddress(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const { publicKeys, partialAddress } = await this.executor.utilityGetCompleteAddress(address);
+        const { publicKeys, partialAddress } = await this.oracleHandler.utilityGetCompleteAddress(address);
         return toForeignCallResult([
             toArray([
                 ...publicKeys.toFields(),
@@ -220,7 +239,7 @@ export class TXEService {
     }
     async utilityGetKeyValidationRequest(foreignPkMHash) {
         const pkMHash = fromSingle(foreignPkMHash);
-        const keyValidationRequest = await this.executor.utilityGetKeyValidationRequest(pkMHash);
+        const keyValidationRequest = await this.oracleHandler.utilityGetKeyValidationRequest(pkMHash);
         return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
     }
     privateCallPrivateFunction(_foreignTargetContractAddress, _foreignFunctionSelector, _foreignArgsHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
@@ -229,7 +248,7 @@ export class TXEService {
     async utilityGetNullifierMembershipWitness(foreignBlockNumber, foreignNullifier) {
         const blockNumber = fromSingle(foreignBlockNumber).toNumber();
         const nullifier = fromSingle(foreignNullifier);
-        const witness = await this.executor.utilityGetNullifierMembershipWitness(blockNumber, nullifier);
+        const witness = await this.oracleHandler.utilityGetNullifierMembershipWitness(blockNumber, nullifier);
         if (!witness) {
             throw new Error(`Nullifier membership witness not found at block ${blockNumber}.`);
         }
@@ -237,7 +256,7 @@ export class TXEService {
     }
     async utilityGetAuthWitness(foreignMessageHash) {
         const messageHash = fromSingle(foreignMessageHash);
-        const authWitness = await this.executor.utilityGetAuthWitness(messageHash);
+        const authWitness = await this.oracleHandler.utilityGetAuthWitness(messageHash);
         if (!authWitness) {
             throw new Error(`Auth witness not found for message hash ${messageHash}.`);
         }
@@ -255,20 +274,20 @@ export class TXEService {
         throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
     }
     async utilityGetChainId() {
-        const chainId = await this.executor.utilityGetChainId();
+        const chainId = await this.oracleHandler.utilityGetChainId();
         return toForeignCallResult([
             toSingle(chainId)
         ]);
     }
     async utilityGetVersion() {
-        const version = await this.executor.utilityGetVersion();
+        const version = await this.oracleHandler.utilityGetVersion();
         return toForeignCallResult([
             toSingle(version)
         ]);
     }
     async utilityGetBlockHeader(foreignBlockNumber) {
         const blockNumber = fromSingle(foreignBlockNumber).toNumber();
-        const header = await this.executor.utilityGetBlockHeader(blockNumber);
+        const header = await this.oracleHandler.utilityGetBlockHeader(blockNumber);
         if (!header) {
             throw new Error(`Block header not found for block ${blockNumber}.`);
         }
@@ -278,7 +297,7 @@ export class TXEService {
         const blockNumber = fromSingle(foreignBlockNumber).toNumber();
         const treeId = fromSingle(foreignTreeId).toNumber();
         const leafValue = fromSingle(foreignLeafValue);
-        const witness = await this.executor.utilityGetMembershipWitness(blockNumber, treeId, leafValue);
+        const witness = await this.oracleHandler.utilityGetMembershipWitness(blockNumber, treeId, leafValue);
         if (!witness) {
             throw new Error(`Membership witness in tree ${MerkleTreeId[treeId]} not found for value ${leafValue} at block ${blockNumber}.`);
         }
@@ -290,7 +309,7 @@ export class TXEService {
     async utilityGetLowNullifierMembershipWitness(foreignBlockNumber, foreignNullifier) {
         const blockNumber = fromSingle(foreignBlockNumber).toNumber();
         const nullifier = fromSingle(foreignNullifier);
-        const witness = await this.executor.utilityGetLowNullifierMembershipWitness(blockNumber, nullifier);
+        const witness = await this.oracleHandler.utilityGetLowNullifierMembershipWitness(blockNumber, nullifier);
         if (!witness) {
             throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockNumber}.`);
         }
@@ -299,40 +318,40 @@ export class TXEService {
     async utilityGetIndexedTaggingSecretAsSender(foreignSender, foreignRecipient) {
         const sender = AztecAddress.fromField(fromSingle(foreignSender));
         const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
-        const secret = await this.executor.utilityGetIndexedTaggingSecretAsSender(sender, recipient);
+        const secret = await this.oracleHandler.utilityGetIndexedTaggingSecretAsSender(sender, recipient);
         return toForeignCallResult(secret.toFields().map(toSingle));
     }
     async utilityFetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot) {
         const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
-        await this.executor.utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
+        await this.oracleHandler.utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
         return toForeignCallResult([]);
     }
     async utilityValidateEnqueuedNotesAndEvents(foreignContractAddress, foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
         const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
-        await this.executor.utilityValidateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot);
+        await this.oracleHandler.utilityValidateEnqueuedNotesAndEvents(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.executor.utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot);
+        await this.oracleHandler.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.executor.utilityStoreCapsule(contractAddress, slot, capsule);
+        await this.oracleHandler.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.executor.utilityLoadCapsule(contractAddress, slot);
+        const values = await this.oracleHandler.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) {
@@ -352,7 +371,7 @@ export class TXEService {
     async utilityDeleteCapsule(foreignContractAddress, foreignSlot) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const slot = fromSingle(foreignSlot);
-        await this.executor.utilityDeleteCapsule(contractAddress, slot);
+        await this.oracleHandler.utilityDeleteCapsule(contractAddress, slot);
         return toForeignCallResult([]);
     }
     async utilityCopyCapsule(foreignContractAddress, foreignSrcSlot, foreignDstSlot, foreignNumEntries) {
@@ -360,7 +379,7 @@ export class TXEService {
         const srcSlot = fromSingle(foreignSrcSlot);
         const dstSlot = fromSingle(foreignDstSlot);
         const numEntries = fromSingle(foreignNumEntries).toNumber();
-        await this.executor.utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+        await this.oracleHandler.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.
@@ -371,7 +390,7 @@ export class TXEService {
         const ciphertext = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
         const iv = fromUintArray(foreignIv, 8);
         const symKey = fromUintArray(foreignSymKey, 8);
-        const plaintextBuffer = await this.executor.utilityAes128Decrypt(ciphertext, iv, symKey);
+        const plaintextBuffer = await this.oracleHandler.utilityAes128Decrypt(ciphertext, iv, symKey);
         return toForeignCallResult(arrayToBoundedVec(bufferToU8Array(plaintextBuffer), foreignCiphertextBVecStorage.length));
     }
     async utilityGetSharedSecret(foreignAddress, foreignEphPKField0, foreignEphPKField1, foreignEphPKField2) {
@@ -381,7 +400,7 @@ export class TXEService {
             fromSingle(foreignEphPKField1),
             fromSingle(foreignEphPKField2)
         ]);
-        const secret = await this.executor.utilityGetSharedSecret(address, ephPK);
+        const secret = await this.oracleHandler.utilityGetSharedSecret(address, ephPK);
         return toForeignCallResult(secret.toFields().map(toSingle));
     }
     emitOffchainEffect(_foreignData) {
@@ -394,7 +413,7 @@ export class TXEService {
     }
     async avmOpcodeStorageRead(foreignSlot) {
         const slot = fromSingle(foreignSlot);
-        const value = (await this.executor.avmOpcodeStorageRead(slot)).value;
+        const value = (await this.oracleHandler.avmOpcodeStorageRead(slot)).value;
         return toForeignCallResult([
             toSingle(new Fr(value))
         ]);
@@ -402,14 +421,12 @@ export class TXEService {
     async avmOpcodeStorageWrite(foreignSlot, foreignValue) {
         const slot = fromSingle(foreignSlot);
         const value = fromSingle(foreignValue);
-        await this.executor.storageWrite(slot, [
-            value
-        ]);
+        await this.oracleHandler.avmOpcodeStorageWrite(slot, value);
         return toForeignCallResult([]);
     }
     async avmOpcodeGetContractInstanceDeployer(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.executor.utilityGetContractInstance(address);
+        const instance = await this.oracleHandler.utilityGetContractInstance(address);
         return toForeignCallResult([
             toSingle(instance.deployer),
             // AVM requires an extra boolean indicating the instance was found
@@ -418,7 +435,7 @@ export class TXEService {
     }
     async avmOpcodeGetContractInstanceClassId(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.executor.utilityGetContractInstance(address);
+        const instance = await this.oracleHandler.utilityGetContractInstance(address);
         return toForeignCallResult([
             toSingle(instance.currentContractClassId),
             // AVM requires an extra boolean indicating the instance was found
@@ -427,7 +444,7 @@ export class TXEService {
     }
     async avmOpcodeGetContractInstanceInitializationHash(foreignAddress) {
         const address = addressFromSingle(foreignAddress);
-        const instance = await this.executor.utilityGetContractInstance(address);
+        const instance = await this.oracleHandler.utilityGetContractInstance(address);
         return toForeignCallResult([
             toSingle(instance.initializationHash),
             // AVM requires an extra boolean indicating the instance was found
@@ -435,62 +452,61 @@ export class TXEService {
         ]);
     }
     avmOpcodeSender() {
-        const sender = this.executor.getMsgSender();
+        const sender = this.oracleHandler.getMsgSender();
         return toForeignCallResult([
             toSingle(sender)
         ]);
     }
     async avmOpcodeEmitNullifier(foreignNullifier) {
         const nullifier = fromSingle(foreignNullifier);
-        await this.executor.avmOpcodeEmitNullifier(nullifier);
+        await this.oracleHandler.avmOpcodeEmitNullifier(nullifier);
         return toForeignCallResult([]);
     }
     async avmOpcodeEmitNoteHash(foreignNoteHash) {
         const noteHash = fromSingle(foreignNoteHash);
-        await this.executor.avmOpcodeEmitNoteHash(noteHash);
+        await this.oracleHandler.avmOpcodeEmitNoteHash(noteHash);
         return toForeignCallResult([]);
     }
     async avmOpcodeNullifierExists(foreignInnerNullifier, foreignTargetAddress) {
         const innerNullifier = fromSingle(foreignInnerNullifier);
         const targetAddress = AztecAddress.fromField(fromSingle(foreignTargetAddress));
-        const exists = await this.executor.avmOpcodeNullifierExists(innerNullifier, targetAddress);
+        const exists = await this.oracleHandler.avmOpcodeNullifierExists(innerNullifier, targetAddress);
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
     async avmOpcodeAddress() {
-        const contractAddress = await this.executor.utilityGetContractAddress();
+        const contractAddress = await this.oracleHandler.avmOpcodeAddress();
         return toForeignCallResult([
             toSingle(contractAddress.toField())
         ]);
     }
     async avmOpcodeBlockNumber() {
-        const blockNumber = await this.executor.utilityGetBlockNumber();
+        const blockNumber = await this.oracleHandler.avmOpcodeBlockNumber();
         return toForeignCallResult([
             toSingle(new Fr(blockNumber))
         ]);
     }
     async avmOpcodeTimestamp() {
-        const timestamp = await this.executor.utilityGetTimestamp();
+        const timestamp = await this.oracleHandler.avmOpcodeTimestamp();
         return toForeignCallResult([
             toSingle(new Fr(timestamp))
         ]);
     }
-    avmOpcodeIsStaticCall() {
-        // TestEnvironment::public_context is always static
-        const isStaticCall = true;
+    async avmOpcodeIsStaticCall() {
+        const isStaticCall = await this.oracleHandler.avmOpcodeIsStaticCall();
         return toForeignCallResult([
             toSingle(new Fr(isStaticCall ? 1 : 0))
         ]);
     }
     async avmOpcodeChainId() {
-        const chainId = await this.executor.utilityGetChainId();
+        const chainId = await this.oracleHandler.avmOpcodeChainId();
         return toForeignCallResult([
             toSingle(chainId)
         ]);
     }
     async avmOpcodeVersion() {
-        const version = await this.executor.utilityGetVersion();
+        const version = await this.oracleHandler.avmOpcodeVersion();
         return toForeignCallResult([
             toSingle(version)
         ]);
@@ -517,7 +533,7 @@ export class TXEService {
         const args = fromArray(foreignArgs);
         const argsHash = fromSingle(foreignArgsHash);
         const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const result = await this.executor.txePrivateCallNewFlow(from, targetContractAddress, functionSelector, args, argsHash, isStaticCall);
+        const result = await this.oracleHandler.txePrivateCallNewFlow(from, targetContractAddress, functionSelector, args, argsHash, isStaticCall);
         return toForeignCallResult([
             toArray([
                 result.endSideEffectCounter,
@@ -530,7 +546,7 @@ export class TXEService {
         const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
         const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
         const argsHash = fromSingle(foreignArgsHash);
-        const result = await this.executor.simulateUtilityFunction(targetContractAddress, functionSelector, argsHash);
+        const result = await this.oracleHandler.simulateUtilityFunction(targetContractAddress, functionSelector, argsHash);
         return toForeignCallResult([
             toSingle(result)
         ]);
@@ -540,7 +556,7 @@ export class TXEService {
         const address = addressFromSingle(foreignAddress);
         const calldata = fromArray(foreignCalldata);
         const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const result = await this.executor.txePublicCallNewFlow(from, address, calldata, isStaticCall);
+        const result = await this.oracleHandler.txePublicCallNewFlow(from, address, calldata, isStaticCall);
         return toForeignCallResult([
             toArray([
                 result.returnsHash,
@@ -549,7 +565,7 @@ export class TXEService {
         ]);
     }
     async privateGetSenderForTags() {
-        const sender = await this.executor.privateGetSenderForTags();
+        const sender = await this.oracleHandler.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
@@ -567,7 +583,7 @@ export class TXEService {
     }
     async privateSetSenderForTags(foreignSenderForTags) {
         const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
-        await this.executor.privateSetSenderForTags(senderForTags);
+        await this.oracleHandler.privateSetSenderForTags(senderForTags);
         return toForeignCallResult([]);
     }
 }

package/dest/txe_session.d.ts

@@ -1,8 +1,13 @@
+import { AztecAddress } from '@aztec/aztec.js';
 import { type Logger } from '@aztec/foundation/log';
 import type { ProtocolContract } from '@aztec/protocol-contracts';
+import type { PrivateContextInputs } from '@aztec/stdlib/kernel';
+import type { UInt32 } from '@aztec/stdlib/types';
+import { TXE } from './oracle/txe_oracle.js';
+import type { TXETypedOracle } from './oracle/txe_typed_oracle.js';
 import { TXEStateMachine } from './state_machine/index.js';
 import { TXEService } from './txe_service/txe_service.js';
-import { type ForeignCallArgs, type ForeignCallResult } from './util/encoding.js';
+import type { ForeignCallArgs, ForeignCallResult } from './util/encoding.js';
 /**
  * A TXE Session can be ine one of four states, which change as the test progresses and different oracles are called.
  * The current state determines which oracles are available.
@@ -29,8 +34,6 @@ declare enum SessionState {
      */
     UTILITY = 3
 }
-declare const STATE_TRANSITION_FUNCTIONS: readonly ["txeSetTopLevelTXEContext", "txeSetPrivateTXEContext", "txeSetPublicTXEContext", "txeSetUtilityTXEContext"];
-type TXESessionStateTransitionFunction = (typeof STATE_TRANSITION_FUNCTIONS)[number];
 type MethodNames<T> = {
     [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
 }[keyof T];
@@ -38,17 +41,24 @@ type MethodNames<T> = {
  * The name of an oracle function that TXE supports, which are a combination of PXE oracles, non-transpiled AVM opcodes,
  * and custom TXE oracles.
  */
-export type TXEOracleFunctionName = MethodNames<TXEService> | TXESessionStateTransitionFunction;
+export type TXEOracleFunctionName = MethodNames<TXEService>;
+export interface TXESessionStateHandler {
+    setTopLevelContext(): Promise<void>;
+    setPublicContext(contractAddress?: AztecAddress): Promise<void>;
+    setPrivateContext(contractAddress?: AztecAddress, historicalBlockNumber?: UInt32): Promise<PrivateContextInputs>;
+    setUtilityContext(contractAddress?: AztecAddress): Promise<void>;
+}
 /**
  * A `TXESession` corresponds to a Noir `#[test]` function, and handles all of its oracle calls, stores test-specific
  * state, etc., independent of all other tests running in parallel.
  */
-export declare class TXESession {
+export declare class TXESession implements TXESessionStateHandler {
     private logger;
     private stateMachine;
-    private service;
+    private oracleHandler;
+    private legacyTXEOracle;
     state: SessionState;
-    constructor(logger: Logger, stateMachine: TXEStateMachine, service: TXEService);
+    constructor(logger: Logger, stateMachine: TXEStateMachine, oracleHandler: TXETypedOracle, legacyTXEOracle: TXE);
     static init(protocolContracts: ProtocolContract[]): Promise<TXESession>;
     /**
      * Processes an oracle function invoked by the Noir test associated to this session.
@@ -57,9 +67,11 @@ export declare class TXESession {
      * @returns The oracle return values.
      */
     processFunction(functionName: TXEOracleFunctionName, inputs: ForeignCallArgs): Promise<ForeignCallResult>;
-    processStateTransition(functionName: TXESessionStateTransitionFunction): SessionState;
-    assertInTopLevelState(): void;
-    assertNotInTopLevelState(): void;
+    setTopLevelContext(): Promise<void>;
+    setPublicContext(contractAddress?: AztecAddress): Promise<void>;
+    setPrivateContext(contractAddress?: AztecAddress, historicalBlockNumber?: UInt32): Promise<PrivateContextInputs>;
+    setUtilityContext(contractAddress?: AztecAddress): Promise<void>;
+    private assertInTopLevelState;
 }
 export {};
 //# sourceMappingURL=txe_session.d.ts.map

package/dest/txe_session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"txe_session.d.ts","sourceRoot":"","sources":["../src/txe_session.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAGlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAUlE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,iBAAiB,EAAuB,MAAM,oBAAoB,CAAC;AAIvG;;;GAGG;AACH,aAAK,YAAY;IACf;;;OAGG;IACH,SAAS,IAAA;IACT;;;cAGU;IACV,OAAO,IAAA;IACP;;gGAE4F;IAC5F,MAAM,IAAA;IACN;;;;OAIG;IACH,OAAO,IAAA;CACR;AAED,QAAA,MAAM,0BAA0B,uHAKtB,CAAC;AAEX,KAAK,iCAAiC,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAErF,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK;CACjE,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,UAAU,CAAC,GAAG,iCAAiC,CAAC;AAEhG;;;GAGG;AACH,qBAAa,UAAU;IAInB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,OAAO;IALjB,KAAK,eAA0B;gBAGrB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,eAAe,EAC7B,OAAO,EAAE,UAAU;WAGhB,IAAI,CAAC,iBAAiB,EAAE,gBAAgB,EAAE;IAwCvD;;;;;OAKG;IACG,eAAe,CAAC,YAAY,EAAE,qBAAqB,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAwB/G,sBAAsB,CAAC,YAAY,EAAE,iCAAiC,GAAG,YAAY;IAoBrF,qBAAqB;IAQrB,wBAAwB;CAKzB"}
+{"version":3,"file":"txe_session.d.ts","sourceRoot":"","sources":["../src/txe_session.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAM,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAGlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAQlE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAI7E;;;GAGG;AACH,aAAK,YAAY;IACf;;;OAGG;IACH,SAAS,IAAA;IACT;;;cAGU;IACV,OAAO,IAAA;IACP;;gGAE4F;IAC5F,MAAM,IAAA;IACN;;;;OAIG;IACH,OAAO,IAAA;CACR;AAED,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK;CACjE,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC;AAE5D,MAAM,WAAW,sBAAsB;IACrC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,gBAAgB,CAAC,eAAe,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE,iBAAiB,CAAC,eAAe,CAAC,EAAE,YAAY,EAAE,qBAAqB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACjH,iBAAiB,CAAC,eAAe,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClE;AAID;;;GAGG;AACH,qBAAa,UAAW,YAAW,sBAAsB;IAIrD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,eAAe;IANzB,KAAK,eAA0B;gBAGrB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,eAAe,EAC7B,aAAa,EAAE,cAAc,EAC7B,eAAe,EAAE,GAAG;WAGjB,IAAI,CAAC,iBAAiB,EAAE,gBAAgB,EAAE;IAsCvD;;;;;OAKG;IACH,eAAe,CAAC,YAAY,EAAE,qBAAqB,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAInG,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BnC,gBAAgB,CAAC,eAAe,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB/D,iBAAiB,CACrB,eAAe,CAAC,EAAE,YAAY,EAC9B,qBAAqB,CAAC,EAAE,MAAM,GAC7B,OAAO,CAAC,oBAAoB,CAAC;IAehC,iBAAiB,CAAC,eAAe,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAahE,OAAO,CAAC,qBAAqB;CAO9B"}