@aztec/txe 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/{txe_service/txe_service.ts → rpc_translator.ts}

@@ -1,11 +1,18 @@
-import { type ContractInstanceWithAddress, Fr, Point } from '@aztec/aztec.js';
-import { packAsRetrievedNote } from '@aztec/pxe/simulator';
+import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
+import { Fr, Point } from '@aztec/aztec.js/fields';
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
+import {
+  type IMiscOracle,
+  type IPrivateExecutionOracle,
+  type IUtilityExecutionOracle,
+  packAsRetrievedNote,
+} from '@aztec/pxe/simulator';
 import { type ContractArtifact, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
-import type { TXETypedOracle } from '../oracle/txe_typed_oracle.js';
-import type { TXESessionStateHandler } from '../txe_session.js';
+import type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.js';
+import type { TXESessionStateHandler } from './txe_session.js';
 import {
   type ForeignCallArray,
   type ForeignCallSingle,
@@ -20,11 +27,17 @@ import {
   toArray,
   toForeignCallResult,
   toSingle,
-} from '../util/encoding.js';
+} from './util/encoding.js';
 
-export class TXEService {
+export class UnavailableOracleError extends Error {
+  constructor(oracleName: string) {
+    super(`${oracleName} oracles not available with the current handler`);
+  }
+}
+
+export class RPCTranslator {
   /**
-   * Create a new instance of `TXEService` that will translate all TXE RPC calls to and from the foreign
+   * Create a new instance of `RPCTranslator` that will translate all TXE RPC calls to and from the foreign
    * (`ForeignCallSingle`, `ForeignCallResult`, etc.) and native TS types, delegating actual execution of the oracles
    * to the different handlers.
    * @param stateHandler The handler that will process TXE session state transitions, such as entering a private or
@@ -34,13 +47,61 @@ export class TXEService {
    */
   constructor(
     private stateHandler: TXESessionStateHandler,
-    private oracleHandler: TXETypedOracle,
+    private oracleHandler:
+      | IMiscOracle
+      | IUtilityExecutionOracle
+      | IPrivateExecutionOracle
+      | IAvmExecutionOracle
+      | ITxeExecutionOracle,
   ) {}
 
+  // Note: If you rename the following functions to not start with "handlerAs", you must also update the validation
+  // check in `TXESession.processFunction`.
+
+  private handlerAsMisc(): IMiscOracle {
+    if (!('isMisc' in this.oracleHandler)) {
+      throw new UnavailableOracleError('Misc');
+    }
+
+    return this.oracleHandler;
+  }
+
+  private handlerAsUtility(): IUtilityExecutionOracle {
+    if (!('isUtility' in this.oracleHandler)) {
+      throw new UnavailableOracleError('Utility');
+    }
+
+    return this.oracleHandler;
+  }
+
+  private handlerAsPrivate(): IPrivateExecutionOracle {
+    if (!('isPrivate' in this.oracleHandler)) {
+      throw new UnavailableOracleError('Private');
+    }
+
+    return this.oracleHandler;
+  }
+
+  private handlerAsAvm(): IAvmExecutionOracle {
+    if (!('isAvm' in this.oracleHandler)) {
+      throw new UnavailableOracleError('Avm');
+    }
+
+    return this.oracleHandler;
+  }
+
+  private handlerAsTxe(): ITxeExecutionOracle {
+    if (!('isTxe' in this.oracleHandler)) {
+      throw new UnavailableOracleError('Txe');
+    }
+
+    return this.oracleHandler;
+  }
+
   // TXE session state transition functions - these get handled by the state handler
 
   async txeSetTopLevelTXEContext() {
-    await this.stateHandler.setTopLevelContext();
+    await this.stateHandler.enterTopLevelState();
 
     return toForeignCallResult([]);
   }
@@ -48,18 +109,18 @@ export class TXEService {
   async txeSetPrivateTXEContext(
     foreignContractAddressIsSome: ForeignCallSingle,
     foreignContractAddressValue: ForeignCallSingle,
-    foreignHistoricalBlockNumberIsSome: ForeignCallSingle,
-    foreignHistoricalBlockNumberValue: ForeignCallSingle,
+    foreignAnchorBlockNumberIsSome: ForeignCallSingle,
+    foreignAnchorBlockNumberValue: ForeignCallSingle,
   ) {
     const contractAddress = fromSingle(foreignContractAddressIsSome).toBool()
       ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
       : undefined;
 
-    const historicalBlockNumber = fromSingle(foreignHistoricalBlockNumberIsSome).toBool()
-      ? fromSingle(foreignHistoricalBlockNumberValue).toNumber()
+    const anchorBlockNumber = fromSingle(foreignAnchorBlockNumberIsSome).toBool()
+      ? fromSingle(foreignAnchorBlockNumberValue).toNumber()
       : undefined;
 
-    const privateContextInputs = await this.stateHandler.setPrivateContext(contractAddress, historicalBlockNumber);
+    const privateContextInputs = await this.stateHandler.enterPrivateState(contractAddress, anchorBlockNumber);
 
     return toForeignCallResult(privateContextInputs.toFields().map(toSingle));
   }
@@ -72,7 +133,7 @@ export class TXEService {
       ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
       : undefined;
 
-    await this.stateHandler.setPublicContext(contractAddress);
+    await this.stateHandler.enterPublicState(contractAddress);
 
     return toForeignCallResult([]);
   }
@@ -85,7 +146,7 @@ export class TXEService {
       ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
       : undefined;
 
-    await this.stateHandler.setUtilityContext(contractAddress);
+    await this.stateHandler.enterUtilityState(contractAddress);
 
     return toForeignCallResult([]);
   }
@@ -94,10 +155,22 @@ export class TXEService {
 
   // TXE-specific oracles
 
+  async txeGetNextBlockNumber() {
+    const nextBlockNumber = await this.handlerAsTxe().txeGetNextBlockNumber();
+
+    return toForeignCallResult([toSingle(nextBlockNumber)]);
+  }
+
+  async txeGetNextBlockTimestamp() {
+    const nextBlockTimestamp = await this.handlerAsTxe().txeGetNextBlockTimestamp();
+
+    return toForeignCallResult([toSingle(nextBlockTimestamp)]);
+  }
+
   async txeAdvanceBlocksBy(foreignBlocks: ForeignCallSingle) {
     const blocks = fromSingle(foreignBlocks).toNumber();
 
-    await this.oracleHandler.txeAdvanceBlocksBy(blocks);
+    await this.handlerAsTxe().txeAdvanceBlocksBy(blocks);
 
     return toForeignCallResult([]);
   }
@@ -105,7 +178,7 @@ export class TXEService {
   txeAdvanceTimestampBy(foreignDuration: ForeignCallSingle) {
     const duration = fromSingle(foreignDuration).toBigInt();
 
-    this.oracleHandler.txeAdvanceTimestampBy(duration);
+    this.handlerAsTxe().txeAdvanceTimestampBy(duration);
 
     return toForeignCallResult([]);
   }
@@ -113,7 +186,7 @@ export class TXEService {
   async txeDeploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: ForeignCallSingle) {
     const secret = fromSingle(foreignSecret);
 
-    await this.oracleHandler.txeDeploy(artifact, instance, secret);
+    await this.handlerAsTxe().txeDeploy(artifact, instance, secret);
 
     return toForeignCallResult([
       toArray([
@@ -129,7 +202,7 @@ export class TXEService {
   async txeCreateAccount(foreignSecret: ForeignCallSingle) {
     const secret = fromSingle(foreignSecret);
 
-    const completeAddress = await this.oracleHandler.txeCreateAccount(secret);
+    const completeAddress = await this.handlerAsTxe().txeCreateAccount(secret);
 
     return toForeignCallResult([
       toSingle(completeAddress.address),
@@ -144,7 +217,7 @@ export class TXEService {
   ) {
     const secret = fromSingle(foreignSecret);
 
-    const completeAddress = await this.oracleHandler.txeAddAccount(artifact, instance, secret);
+    const completeAddress = await this.handlerAsTxe().txeAddAccount(artifact, instance, secret);
 
     return toForeignCallResult([
       toSingle(completeAddress.address),
@@ -156,7 +229,7 @@ export class TXEService {
     const address = addressFromSingle(foreignAddress);
     const messageHash = fromSingle(foreignMessageHash);
 
-    await this.oracleHandler.txeAddAuthWitness(address, messageHash);
+    await this.handlerAsTxe().txeAddAuthWitness(address, messageHash);
 
     return toForeignCallResult([]);
   }
@@ -166,40 +239,31 @@ export class TXEService {
   utilityAssertCompatibleOracleVersion(foreignVersion: ForeignCallSingle) {
     const version = fromSingle(foreignVersion).toNumber();
 
-    this.oracleHandler.utilityAssertCompatibleOracleVersion(version);
+    this.handlerAsMisc().utilityAssertCompatibleOracleVersion(version);
 
     return toForeignCallResult([]);
   }
 
   utilityGetRandomField() {
-    const randomField = this.oracleHandler.utilityGetRandomField();
+    const randomField = this.handlerAsMisc().utilityGetRandomField();
 
     return toForeignCallResult([toSingle(randomField)]);
   }
 
-  async utilityGetContractAddress() {
-    const contractAddress = await this.oracleHandler.utilityGetContractAddress();
-
-    return toForeignCallResult([toSingle(contractAddress.toField())]);
-  }
-
-  async 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.oracleHandler.utilityGetTimestamp();
+  async txeGetLastBlockTimestamp() {
+    const timestamp = await this.handlerAsTxe().txeGetLastBlockTimestamp();
 
     return toForeignCallResult([toSingle(new Fr(timestamp))]);
   }
 
-  async txeGetLastBlockTimestamp() {
-    const timestamp = await this.oracleHandler.txeGetLastBlockTimestamp();
+  async txeGetLastTxEffects() {
+    const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().txeGetLastTxEffects();
 
-    return toForeignCallResult([toSingle(new Fr(timestamp))]);
+    return toForeignCallResult([
+      toSingle(txHash.hash),
+      ...arrayToBoundedVec(toArray(noteHashes), MAX_NOTE_HASHES_PER_TX),
+      ...arrayToBoundedVec(toArray(nullifiers), MAX_NULLIFIERS_PER_TX),
+    ]);
   }
 
   // Since the argument is a slice, noir automatically adds a length field to oracle call.
@@ -211,7 +275,7 @@ export class TXEService {
     const values = fromArray(foreignValues);
     const hash = fromSingle(foreignHash);
 
-    this.oracleHandler.privateStoreInExecutionCache(values, hash);
+    this.handlerAsPrivate().privateStoreInExecutionCache(values, hash);
 
     return toForeignCallResult([]);
   }
@@ -219,23 +283,26 @@ export class TXEService {
   async privateLoadFromExecutionCache(foreignHash: ForeignCallSingle) {
     const hash = fromSingle(foreignHash);
 
-    const returns = await this.oracleHandler.privateLoadFromExecutionCache(hash);
+    const returns = await this.handlerAsPrivate().privateLoadFromExecutionCache(hash);
 
     return toForeignCallResult([toArray(returns)]);
   }
 
-  // Since the argument is a slice, noir automatically adds a length field to oracle call.
+  // When the argument is a slice, noir automatically adds a length field to oracle call.
+  // When the argument is an array, we add the field length manually to the signature.
   utilityDebugLog(
+    foreignLevel: ForeignCallSingle,
     foreignMessage: ForeignCallArray,
     _foreignLength: ForeignCallSingle,
     foreignFields: ForeignCallArray,
   ) {
+    const level = fromSingle(foreignLevel).toNumber();
     const message = fromArray(foreignMessage)
       .map(field => String.fromCharCode(field.toNumber()))
       .join('');
     const fields = fromArray(foreignFields);
 
-    this.oracleHandler.utilityDebugLog(message, fields);
+    this.handlerAsMisc().utilityDebugLog(level, message, fields);
 
     return toForeignCallResult([]);
   }
@@ -251,7 +318,7 @@ export class TXEService {
     const blockNumber = fromSingle(foreignBlockNumber).toNumber();
     const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
 
-    const values = await this.oracleHandler.utilityStorageRead(
+    const values = await this.handlerAsUtility().utilityStorageRead(
       contractAddress,
       startStorageSlot,
       blockNumber,
@@ -265,7 +332,7 @@ export class TXEService {
     const blockNumber = fromSingle(foreignBlockNumber).toNumber();
     const leafSlot = fromSingle(foreignLeafSlot);
 
-    const witness = await this.oracleHandler.utilityGetPublicDataWitness(blockNumber, leafSlot);
+    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(blockNumber, leafSlot);
 
     if (!witness) {
       throw new Error(`Public data witness not found for slot ${leafSlot} at block ${blockNumber}.`);
@@ -308,7 +375,7 @@ export class TXEService {
     const maxNotes = fromSingle(foreignMaxNotes).toNumber();
     const packedRetrievedNoteLength = fromSingle(foreignPackedRetrievedNoteLength).toNumber();
 
-    const noteDatas = await this.oracleHandler.utilityGetNotes(
+    const noteDatas = await this.handlerAsUtility().utilityGetNotes(
       storageSlot,
       numSelects,
       selectByIndexes,
@@ -355,7 +422,7 @@ export class TXEService {
     const noteHash = fromSingle(foreignNoteHash);
     const counter = fromSingle(foreignCounter).toNumber();
 
-    this.oracleHandler.privateNotifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter);
+    this.handlerAsPrivate().privateNotifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter);
 
     return toForeignCallResult([]);
   }
@@ -369,7 +436,7 @@ export class TXEService {
     const noteHash = fromSingle(foreignNoteHash);
     const counter = fromSingle(foreignCounter).toNumber();
 
-    await this.oracleHandler.privateNotifyNullifiedNote(innerNullifier, noteHash, counter);
+    await this.handlerAsPrivate().privateNotifyNullifiedNote(innerNullifier, noteHash, counter);
 
     return toForeignCallResult([]);
   }
@@ -377,7 +444,7 @@ export class TXEService {
   async privateNotifyCreatedNullifier(foreignInnerNullifier: ForeignCallSingle) {
     const innerNullifier = fromSingle(foreignInnerNullifier);
 
-    await this.oracleHandler.privateNotifyCreatedNullifier(innerNullifier);
+    await this.handlerAsPrivate().privateNotifyCreatedNullifier(innerNullifier);
 
     return toForeignCallResult([]);
   }
@@ -385,7 +452,7 @@ export class TXEService {
   async utilityCheckNullifierExists(foreignInnerNullifier: ForeignCallSingle) {
     const innerNullifier = fromSingle(foreignInnerNullifier);
 
-    const exists = await this.oracleHandler.utilityCheckNullifierExists(innerNullifier);
+    const exists = await this.handlerAsUtility().utilityCheckNullifierExists(innerNullifier);
 
     return toForeignCallResult([toSingle(new Fr(exists))]);
   }
@@ -393,7 +460,7 @@ export class TXEService {
   async utilityGetContractInstance(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.oracleHandler.utilityGetContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult(
       [
@@ -409,7 +476,7 @@ export class TXEService {
   async utilityGetPublicKeysAndPartialAddress(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const { publicKeys, partialAddress } = await this.oracleHandler.utilityGetCompleteAddress(address);
+    const { publicKeys, partialAddress } = await this.handlerAsUtility().utilityGetPublicKeysAndPartialAddress(address);
 
     return toForeignCallResult([toArray([...publicKeys.toFields(), partialAddress])]);
   }
@@ -417,7 +484,7 @@ export class TXEService {
   async utilityGetKeyValidationRequest(foreignPkMHash: ForeignCallSingle) {
     const pkMHash = fromSingle(foreignPkMHash);
 
-    const keyValidationRequest = await this.oracleHandler.utilityGetKeyValidationRequest(pkMHash);
+    const keyValidationRequest = await this.handlerAsUtility().utilityGetKeyValidationRequest(pkMHash);
 
     return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
   }
@@ -441,7 +508,7 @@ export class TXEService {
     const blockNumber = fromSingle(foreignBlockNumber).toNumber();
     const nullifier = fromSingle(foreignNullifier);
 
-    const witness = await this.oracleHandler.utilityGetNullifierMembershipWitness(blockNumber, nullifier);
+    const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(blockNumber, nullifier);
 
     if (!witness) {
       throw new Error(`Nullifier membership witness not found at block ${blockNumber}.`);
@@ -452,7 +519,7 @@ export class TXEService {
   async utilityGetAuthWitness(foreignMessageHash: ForeignCallSingle) {
     const messageHash = fromSingle(foreignMessageHash);
 
-    const authWitness = await this.oracleHandler.utilityGetAuthWitness(messageHash);
+    const authWitness = await this.handlerAsUtility().utilityGetAuthWitness(messageHash);
 
     if (!authWitness) {
       throw new Error(`Auth witness not found for message hash ${messageHash}.`);
@@ -482,22 +549,16 @@ export class TXEService {
     throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
   }
 
-  async utilityGetChainId() {
-    const chainId = await this.oracleHandler.utilityGetChainId();
+  async utilityGetUtilityContext() {
+    const context = await this.handlerAsUtility().utilityGetUtilityContext();
 
-    return toForeignCallResult([toSingle(chainId)]);
-  }
-
-  async utilityGetVersion() {
-    const version = await this.oracleHandler.utilityGetVersion();
-
-    return toForeignCallResult([toSingle(version)]);
+    return toForeignCallResult(context.toNoirRepresentation());
   }
 
   async utilityGetBlockHeader(foreignBlockNumber: ForeignCallSingle) {
     const blockNumber = fromSingle(foreignBlockNumber).toNumber();
 
-    const header = await this.oracleHandler.utilityGetBlockHeader(blockNumber);
+    const header = await this.handlerAsUtility().utilityGetBlockHeader(blockNumber);
 
     if (!header) {
       throw new Error(`Block header not found for block ${blockNumber}.`);
@@ -514,7 +575,7 @@ export class TXEService {
     const treeId = fromSingle(foreignTreeId).toNumber();
     const leafValue = fromSingle(foreignLeafValue);
 
-    const witness = await this.oracleHandler.utilityGetMembershipWitness(blockNumber, treeId, leafValue);
+    const witness = await this.handlerAsUtility().utilityGetMembershipWitness(blockNumber, treeId, leafValue);
 
     if (!witness) {
       throw new Error(
@@ -531,7 +592,7 @@ export class TXEService {
     const blockNumber = fromSingle(foreignBlockNumber).toNumber();
     const nullifier = fromSingle(foreignNullifier);
 
-    const witness = await this.oracleHandler.utilityGetLowNullifierMembershipWitness(blockNumber, nullifier);
+    const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(blockNumber, nullifier);
 
     if (!witness) {
       throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockNumber}.`);
@@ -539,19 +600,10 @@ export class TXEService {
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
-  async utilityGetIndexedTaggingSecretAsSender(foreignSender: ForeignCallSingle, foreignRecipient: ForeignCallSingle) {
-    const sender = AztecAddress.fromField(fromSingle(foreignSender));
-    const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
-
-    const secret = await this.oracleHandler.utilityGetIndexedTaggingSecretAsSender(sender, recipient);
-
-    return toForeignCallResult(secret.toFields().map(toSingle));
-  }
-
   async utilityFetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot: ForeignCallSingle) {
     const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
 
-    await this.oracleHandler.utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
+    await this.handlerAsUtility().utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
 
     return toForeignCallResult([]);
   }
@@ -565,7 +617,7 @@ export class TXEService {
     const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
     const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
 
-    await this.oracleHandler.utilityValidateEnqueuedNotesAndEvents(
+    await this.handlerAsUtility().utilityValidateEnqueuedNotesAndEvents(
       contractAddress,
       noteValidationRequestsArrayBaseSlot,
       eventValidationRequestsArrayBaseSlot,
@@ -583,7 +635,7 @@ export class TXEService {
     const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
     const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
 
-    await this.oracleHandler.utilityBulkRetrieveLogs(
+    await this.handlerAsUtility().utilityBulkRetrieveLogs(
       contractAddress,
       logRetrievalRequestsArrayBaseSlot,
       logRetrievalResponsesArrayBaseSlot,
@@ -601,7 +653,7 @@ export class TXEService {
     const slot = fromSingle(foreignSlot);
     const capsule = fromArray(foreignCapsule);
 
-    await this.oracleHandler.utilityStoreCapsule(contractAddress, slot, capsule);
+    await this.handlerAsUtility().utilityStoreCapsule(contractAddress, slot, capsule);
 
     return toForeignCallResult([]);
   }
@@ -615,7 +667,7 @@ export class TXEService {
     const slot = fromSingle(foreignSlot);
     const tSize = fromSingle(foreignTSize).toNumber();
 
-    const values = await this.oracleHandler.utilityLoadCapsule(contractAddress, slot);
+    const values = await this.handlerAsUtility().utilityLoadCapsule(contractAddress, slot);
 
     // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
     // with two fields: `some` (a boolean) and `value` (a field array in this case).
@@ -632,7 +684,7 @@ export class TXEService {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const slot = fromSingle(foreignSlot);
 
-    await this.oracleHandler.utilityDeleteCapsule(contractAddress, slot);
+    await this.handlerAsUtility().utilityDeleteCapsule(contractAddress, slot);
 
     return toForeignCallResult([]);
   }
@@ -648,7 +700,7 @@ export class TXEService {
     const dstSlot = fromSingle(foreignDstSlot);
     const numEntries = fromSingle(foreignNumEntries).toNumber();
 
-    await this.oracleHandler.utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+    await this.handlerAsUtility().utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
 
     return toForeignCallResult([]);
   }
@@ -667,7 +719,7 @@ export class TXEService {
     const iv = fromUintArray(foreignIv, 8);
     const symKey = fromUintArray(foreignSymKey, 8);
 
-    const plaintextBuffer = await this.oracleHandler.utilityAes128Decrypt(ciphertext, iv, symKey);
+    const plaintextBuffer = await this.handlerAsUtility().utilityAes128Decrypt(ciphertext, iv, symKey);
 
     return toForeignCallResult(
       arrayToBoundedVec(bufferToU8Array(plaintextBuffer), foreignCiphertextBVecStorage.length),
@@ -687,7 +739,7 @@ export class TXEService {
       fromSingle(foreignEphPKField2),
     ]);
 
-    const secret = await this.oracleHandler.utilityGetSharedSecret(address, ephPK);
+    const secret = await this.handlerAsUtility().utilityGetSharedSecret(address, ephPK);
 
     return toForeignCallResult(secret.toFields().map(toSingle));
   }
@@ -706,7 +758,7 @@ export class TXEService {
   async avmOpcodeStorageRead(foreignSlot: ForeignCallSingle) {
     const slot = fromSingle(foreignSlot);
 
-    const value = (await this.oracleHandler.avmOpcodeStorageRead(slot)).value;
+    const value = (await this.handlerAsAvm().avmOpcodeStorageRead(slot)).value;
 
     return toForeignCallResult([toSingle(new Fr(value))]);
   }
@@ -715,7 +767,7 @@ export class TXEService {
     const slot = fromSingle(foreignSlot);
     const value = fromSingle(foreignValue);
 
-    await this.oracleHandler.avmOpcodeStorageWrite(slot, value);
+    await this.handlerAsAvm().avmOpcodeStorageWrite(slot, value);
 
     return toForeignCallResult([]);
   }
@@ -723,7 +775,7 @@ export class TXEService {
   async avmOpcodeGetContractInstanceDeployer(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.oracleHandler.utilityGetContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult([
       toSingle(instance.deployer),
@@ -735,7 +787,7 @@ export class TXEService {
   async avmOpcodeGetContractInstanceClassId(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.oracleHandler.utilityGetContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult([
       toSingle(instance.currentContractClassId),
@@ -747,7 +799,7 @@ export class TXEService {
   async avmOpcodeGetContractInstanceInitializationHash(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const instance = await this.oracleHandler.utilityGetContractInstance(address);
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(address);
 
     return toForeignCallResult([
       toSingle(instance.initializationHash),
@@ -756,8 +808,8 @@ export class TXEService {
     ]);
   }
 
-  avmOpcodeSender() {
-    const sender = this.oracleHandler.getMsgSender();
+  async avmOpcodeSender() {
+    const sender = await this.handlerAsAvm().avmOpcodeSender();
 
     return toForeignCallResult([toSingle(sender)]);
   }
@@ -765,7 +817,7 @@ export class TXEService {
   async avmOpcodeEmitNullifier(foreignNullifier: ForeignCallSingle) {
     const nullifier = fromSingle(foreignNullifier);
 
-    await this.oracleHandler.avmOpcodeEmitNullifier(nullifier);
+    await this.handlerAsAvm().avmOpcodeEmitNullifier(nullifier);
 
     return toForeignCallResult([]);
   }
@@ -773,7 +825,7 @@ export class TXEService {
   async avmOpcodeEmitNoteHash(foreignNoteHash: ForeignCallSingle) {
     const noteHash = fromSingle(foreignNoteHash);
 
-    await this.oracleHandler.avmOpcodeEmitNoteHash(noteHash);
+    await this.handlerAsAvm().avmOpcodeEmitNoteHash(noteHash);
 
     return toForeignCallResult([]);
   }
@@ -782,43 +834,43 @@ export class TXEService {
     const innerNullifier = fromSingle(foreignInnerNullifier);
     const targetAddress = AztecAddress.fromField(fromSingle(foreignTargetAddress));
 
-    const exists = await this.oracleHandler.avmOpcodeNullifierExists(innerNullifier, targetAddress);
+    const exists = await this.handlerAsAvm().avmOpcodeNullifierExists(innerNullifier, targetAddress);
 
     return toForeignCallResult([toSingle(new Fr(exists))]);
   }
 
   async avmOpcodeAddress() {
-    const contractAddress = await this.oracleHandler.avmOpcodeAddress();
+    const contractAddress = await this.handlerAsAvm().avmOpcodeAddress();
 
     return toForeignCallResult([toSingle(contractAddress.toField())]);
   }
 
   async avmOpcodeBlockNumber() {
-    const blockNumber = await this.oracleHandler.avmOpcodeBlockNumber();
+    const blockNumber = await this.handlerAsAvm().avmOpcodeBlockNumber();
 
     return toForeignCallResult([toSingle(new Fr(blockNumber))]);
   }
 
   async avmOpcodeTimestamp() {
-    const timestamp = await this.oracleHandler.avmOpcodeTimestamp();
+    const timestamp = await this.handlerAsAvm().avmOpcodeTimestamp();
 
     return toForeignCallResult([toSingle(new Fr(timestamp))]);
   }
 
   async avmOpcodeIsStaticCall() {
-    const isStaticCall = await this.oracleHandler.avmOpcodeIsStaticCall();
+    const isStaticCall = await this.handlerAsAvm().avmOpcodeIsStaticCall();
 
     return toForeignCallResult([toSingle(new Fr(isStaticCall ? 1 : 0))]);
   }
 
   async avmOpcodeChainId() {
-    const chainId = await this.oracleHandler.avmOpcodeChainId();
+    const chainId = await this.handlerAsAvm().avmOpcodeChainId();
 
     return toForeignCallResult([toSingle(chainId)]);
   }
 
   async avmOpcodeVersion() {
-    const version = await this.oracleHandler.avmOpcodeVersion();
+    const version = await this.handlerAsAvm().avmOpcodeVersion();
 
     return toForeignCallResult([toSingle(version)]);
   }
@@ -881,7 +933,7 @@ export class TXEService {
     const argsHash = fromSingle(foreignArgsHash);
     const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
 
-    const result = await this.oracleHandler.txePrivateCallNewFlow(
+    const returnValues = await this.handlerAsTxe().txePrivateCallNewFlow(
       from,
       targetContractAddress,
       functionSelector,
@@ -890,21 +942,26 @@ export class TXEService {
       isStaticCall,
     );
 
-    return toForeignCallResult([toArray([result.endSideEffectCounter, result.returnsHash, result.txHash.hash])]);
+    return toForeignCallResult([toArray(returnValues)]);
   }
 
-  async simulateUtilityFunction(
+  async txeSimulateUtilityFunction(
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
-    foreignArgsHash: ForeignCallSingle,
+    _foreignArgsLength: ForeignCallSingle,
+    foreignArgs: ForeignCallArray,
   ) {
     const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
     const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
-    const argsHash = fromSingle(foreignArgsHash);
+    const args = fromArray(foreignArgs);
 
-    const result = await this.oracleHandler.simulateUtilityFunction(targetContractAddress, functionSelector, argsHash);
+    const returnValues = await this.handlerAsTxe().txeSimulateUtilityFunction(
+      targetContractAddress,
+      functionSelector,
+      args,
+    );
 
-    return toForeignCallResult([toSingle(result)]);
+    return toForeignCallResult([toArray(returnValues)]);
   }
 
   async txePublicCallNewFlow(
@@ -919,13 +976,13 @@ export class TXEService {
     const calldata = fromArray(foreignCalldata);
     const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
 
-    const result = await this.oracleHandler.txePublicCallNewFlow(from, address, calldata, isStaticCall);
+    const returnValues = await this.handlerAsTxe().txePublicCallNewFlow(from, address, calldata, isStaticCall);
 
-    return toForeignCallResult([toArray([result.returnsHash, result.txHash.hash])]);
+    return toForeignCallResult([toArray(returnValues)]);
   }
 
   async privateGetSenderForTags() {
-    const sender = await this.oracleHandler.privateGetSenderForTags();
+    const sender = await this.handlerAsPrivate().privateGetSenderForTags();
 
     // Return a Noir Option struct with `some` and `value` fields
     if (sender === undefined) {
@@ -940,8 +997,17 @@ export class TXEService {
   async privateSetSenderForTags(foreignSenderForTags: ForeignCallSingle) {
     const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
 
-    await this.oracleHandler.privateSetSenderForTags(senderForTags);
+    await this.handlerAsPrivate().privateSetSenderForTags(senderForTags);
 
     return toForeignCallResult([]);
   }
+
+  async privateGetNextAppTagAsSender(foreignSender: ForeignCallSingle, foreignRecipient: ForeignCallSingle) {
+    const sender = AztecAddress.fromField(fromSingle(foreignSender));
+    const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
+
+    const nextAppTag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(sender, recipient);
+
+    return toForeignCallResult([toSingle(nextAppTag.value)]);
+  }
 }