@aztec/txe 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

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

@@ -1,11 +1,19 @@
-import { type ContractInstanceWithAddress, Fr, Point } from '@aztec/aztec.js';
-import { packAsRetrievedNote } from '@aztec/pxe/simulator';
-import { type ContractArtifact, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+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 { BlockNumber } from '@aztec/foundation/branded-types';
+import {
+  type IMiscOracle,
+  type IPrivateExecutionOracle,
+  type IUtilityExecutionOracle,
+  packAsRetrievedNote,
+} from '@aztec/pxe/simulator';
+import { type ContractArtifact, EventSelector, 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 +28,20 @@ import {
   toArray,
   toForeignCallResult,
   toSingle,
-} from '../util/encoding.js';
+} from './util/encoding.js';
+
+const MAX_EVENT_LEN = 12; // This is MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_RESERVED_FIELDS
+const MAX_PRIVATE_EVENTS_PER_TXE_QUERY = 5;
+
+export class UnavailableOracleError extends Error {
+  constructor(oracleName: string) {
+    super(`${oracleName} oracles not available with the current handler`);
+  }
+}
 
-export class TXEService {
+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 +51,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 +113,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()
+      ? BlockNumber(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 +137,7 @@ export class TXEService {
       ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
       : undefined;
 
-    await this.stateHandler.setPublicContext(contractAddress);
+    await this.stateHandler.enterPublicState(contractAddress);
 
     return toForeignCallResult([]);
   }
@@ -85,7 +150,7 @@ export class TXEService {
       ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
       : undefined;
 
-    await this.stateHandler.setUtilityContext(contractAddress);
+    await this.stateHandler.enterUtilityState(contractAddress);
 
     return toForeignCallResult([]);
   }
@@ -94,10 +159,28 @@ export class TXEService {
 
   // TXE-specific oracles
 
+  txeGetDefaultAddress() {
+    const defaultAddress = this.handlerAsTxe().txeGetDefaultAddress();
+
+    return toForeignCallResult([toSingle(defaultAddress)]);
+  }
+
+  async txeGetNextBlockNumber() {
+    const nextBlockNumber = await this.handlerAsTxe().txeGetNextBlockNumber();
+
+    return toForeignCallResult([toSingle(nextBlockNumber)]);
+  }
+
+  async txeGetNextBlockTimestamp() {
+    const nextBlockTimestamp = await this.handlerAsTxe().txeGetNextBlockTimestamp();
+
+    return toForeignCallResult([toSingle(nextBlockTimestamp)]);
+  }
+
   async txeAdvanceBlocksBy(foreignBlocks: ForeignCallSingle) {
     const blocks = fromSingle(foreignBlocks).toNumber();
 
-    await this.oracleHandler.txeAdvanceBlocksBy(blocks);
+    await this.handlerAsTxe().txeAdvanceBlocksBy(blocks);
 
     return toForeignCallResult([]);
   }
@@ -105,7 +188,7 @@ export class TXEService {
   txeAdvanceTimestampBy(foreignDuration: ForeignCallSingle) {
     const duration = fromSingle(foreignDuration).toBigInt();
 
-    this.oracleHandler.txeAdvanceTimestampBy(duration);
+    this.handlerAsTxe().txeAdvanceTimestampBy(duration);
 
     return toForeignCallResult([]);
   }
@@ -113,7 +196,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 +212,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 +227,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 +239,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,52 +249,71 @@ 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();
+  async txeGetLastBlockTimestamp() {
+    const timestamp = await this.handlerAsTxe().txeGetLastBlockTimestamp();
 
-    return toForeignCallResult([toSingle(contractAddress.toField())]);
+    return toForeignCallResult([toSingle(new Fr(timestamp))]);
   }
 
-  async utilityGetBlockNumber() {
-    const blockNumber = await this.oracleHandler.utilityGetBlockNumber();
+  async txeGetLastTxEffects() {
+    const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().txeGetLastTxEffects();
 
-    return toForeignCallResult([toSingle(new Fr(blockNumber))]);
+    return toForeignCallResult([
+      toSingle(txHash.hash),
+      ...arrayToBoundedVec(toArray(noteHashes), MAX_NOTE_HASHES_PER_TX),
+      ...arrayToBoundedVec(toArray(nullifiers), MAX_NULLIFIERS_PER_TX),
+    ]);
   }
 
-  // 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 txeGetPrivateEvents(
+    foreignSelector: ForeignCallSingle,
+    foreignContractAddress: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
+  ) {
+    const selector = EventSelector.fromField(fromSingle(foreignSelector));
+    const contractAddress = addressFromSingle(foreignContractAddress);
+    const scope = addressFromSingle(foreignScope);
 
-    return toForeignCallResult([toSingle(new Fr(timestamp))]);
-  }
+    const events = await this.handlerAsTxe().txeGetPrivateEvents(selector, contractAddress, scope);
 
-  async txeGetLastBlockTimestamp() {
-    const timestamp = await this.oracleHandler.txeGetLastBlockTimestamp();
+    if (events.length > MAX_PRIVATE_EVENTS_PER_TXE_QUERY) {
+      throw new Error(`Array of length ${events.length} larger than maxLen ${MAX_PRIVATE_EVENTS_PER_TXE_QUERY}`);
+    }
 
-    return toForeignCallResult([toSingle(new Fr(timestamp))]);
+    if (events.some(e => e.length > MAX_EVENT_LEN)) {
+      throw new Error(`Some private event has length larger than maxLen ${MAX_EVENT_LEN}`);
+    }
+
+    // This is a workaround as Noir does not currently let us return nested structs with arrays. We instead return a raw
+    // multidimensional array in get_private_events_oracle and create the BoundedVecs here.
+    const rawArrayStorage = events
+      .map(e => e.concat(Array(MAX_EVENT_LEN - e.length).fill(new Fr(0))))
+      .concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(Array(MAX_EVENT_LEN).fill(new Fr(0))))
+      .flat();
+    const eventLengths = events
+      .map(e => new Fr(e.length))
+      .concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(new Fr(0)));
+    const queryLength = new Fr(events.length);
+
+    return toForeignCallResult([toArray(rawArrayStorage), toArray(eventLengths), toSingle(queryLength)]);
   }
 
-  // Since the argument is a slice, noir automatically adds a length field to oracle call.
-  privateStoreInExecutionCache(
-    _foreignLength: ForeignCallSingle,
-    foreignValues: ForeignCallArray,
-    foreignHash: ForeignCallSingle,
-  ) {
+  privateStoreInExecutionCache(foreignValues: ForeignCallArray, foreignHash: ForeignCallSingle) {
     const values = fromArray(foreignValues);
     const hash = fromSingle(foreignHash);
 
-    this.oracleHandler.privateStoreInExecutionCache(values, hash);
+    this.handlerAsPrivate().privateStoreInExecutionCache(values, hash);
 
     return toForeignCallResult([]);
   }
@@ -219,23 +321,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([]);
   }
@@ -248,10 +353,10 @@ export class TXEService {
   ) {
     const contractAddress = addressFromSingle(foreignContractAddress);
     const startStorageSlot = fromSingle(foreignStartStorageSlot);
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
     const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
 
-    const values = await this.oracleHandler.utilityStorageRead(
+    const values = await this.handlerAsUtility().utilityStorageRead(
       contractAddress,
       startStorageSlot,
       blockNumber,
@@ -262,10 +367,10 @@ export class TXEService {
   }
 
   async utilityGetPublicDataWitness(foreignBlockNumber: ForeignCallSingle, foreignLeafSlot: ForeignCallSingle) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = 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}.`);
@@ -274,6 +379,8 @@ export class TXEService {
   }
 
   async utilityGetNotes(
+    foreignOwnerIsSome: ForeignCallSingle,
+    foreignOwnerValue: ForeignCallSingle,
     foreignStorageSlot: ForeignCallSingle,
     foreignNumSelects: ForeignCallSingle,
     foreignSelectByIndexes: ForeignCallArray,
@@ -291,6 +398,10 @@ export class TXEService {
     foreignMaxNotes: ForeignCallSingle,
     foreignPackedRetrievedNoteLength: ForeignCallSingle,
   ) {
+    // Parse Option<AztecAddress>: ownerIsSome is 0 for None, 1 for Some
+    const owner = fromSingle(foreignOwnerIsSome).toBool()
+      ? AztecAddress.fromField(fromSingle(foreignOwnerValue))
+      : undefined;
     const storageSlot = fromSingle(foreignStorageSlot);
     const numSelects = fromSingle(foreignNumSelects).toNumber();
     const selectByIndexes = fromArray(foreignSelectByIndexes).map(fr => fr.toNumber());
@@ -308,7 +419,8 @@ 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(
+      owner,
       storageSlot,
       numSelects,
       selectByIndexes,
@@ -325,7 +437,17 @@ export class TXEService {
       status,
     );
 
-    const returnDataAsArrayOfArrays = noteDatas.map(packAsRetrievedNote);
+    const returnDataAsArrayOfArrays = noteDatas.map(noteData =>
+      packAsRetrievedNote({
+        contractAddress: noteData.contractAddress,
+        owner: noteData.owner,
+        randomness: noteData.randomness,
+        storageSlot: noteData.storageSlot,
+        noteNonce: noteData.noteNonce,
+        index: noteData.index,
+        note: noteData.note,
+      }),
+    );
 
     // Now we convert each sub-array to an array of ForeignCallSingles
     const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map(subArray =>
@@ -343,19 +465,31 @@ export class TXEService {
   }
 
   privateNotifyCreatedNote(
+    foreignOwner: ForeignCallSingle,
     foreignStorageSlot: ForeignCallSingle,
+    foreignRandomness: ForeignCallSingle,
     foreignNoteTypeId: ForeignCallSingle,
     foreignNote: ForeignCallArray,
     foreignNoteHash: ForeignCallSingle,
     foreignCounter: ForeignCallSingle,
   ) {
+    const owner = addressFromSingle(foreignOwner);
     const storageSlot = fromSingle(foreignStorageSlot);
+    const randomness = fromSingle(foreignRandomness);
     const noteTypeId = NoteSelector.fromField(fromSingle(foreignNoteTypeId));
     const note = fromArray(foreignNote);
     const noteHash = fromSingle(foreignNoteHash);
     const counter = fromSingle(foreignCounter).toNumber();
 
-    this.oracleHandler.privateNotifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter);
+    this.handlerAsPrivate().privateNotifyCreatedNote(
+      owner,
+      storageSlot,
+      randomness,
+      noteTypeId,
+      note,
+      noteHash,
+      counter,
+    );
 
     return toForeignCallResult([]);
   }
@@ -369,7 +503,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 +511,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 +519,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 +527,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 +543,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 +551,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));
   }
@@ -438,10 +572,10 @@ export class TXEService {
     foreignBlockNumber: ForeignCallSingle,
     foreignNullifier: ForeignCallSingle,
   ) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = 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 +586,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 +616,22 @@ export class TXEService {
     throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
   }
 
-  async utilityGetChainId() {
-    const chainId = await this.oracleHandler.utilityGetChainId();
-
-    return toForeignCallResult([toSingle(chainId)]);
+  public async privateIsSideEffectCounterRevertible(foreignSideEffectCounter: ForeignCallSingle) {
+    const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
+    const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(sideEffectCounter);
+    return toForeignCallResult([toSingle(new Fr(isRevertible))]);
   }
 
-  async utilityGetVersion() {
-    const version = await this.oracleHandler.utilityGetVersion();
+  utilityGetUtilityContext() {
+    const context = this.handlerAsUtility().utilityGetUtilityContext();
 
-    return toForeignCallResult([toSingle(version)]);
+    return toForeignCallResult(context.toNoirRepresentation());
   }
 
   async utilityGetBlockHeader(foreignBlockNumber: ForeignCallSingle) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = 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}.`);
@@ -510,11 +644,11 @@ export class TXEService {
     foreignTreeId: ForeignCallSingle,
     foreignLeafValue: ForeignCallSingle,
   ) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
     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(
@@ -528,10 +662,10 @@ export class TXEService {
     foreignBlockNumber: ForeignCallSingle,
     foreignNullifier: ForeignCallSingle,
   ) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = 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 +673,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 +690,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 +708,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 +726,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 +740,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 +757,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 +773,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 +792,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 +812,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 +831,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 +840,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 +848,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 +860,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 +872,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 +881,8 @@ export class TXEService {
     ]);
   }
 
-  avmOpcodeSender() {
-    const sender = this.oracleHandler.getMsgSender();
+  async avmOpcodeSender() {
+    const sender = await this.handlerAsAvm().avmOpcodeSender();
 
     return toForeignCallResult([toSingle(sender)]);
   }
@@ -765,7 +890,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 +898,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 +907,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)]);
   }
@@ -869,7 +994,6 @@ export class TXEService {
     foreignFrom: ForeignCallSingle,
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
-    _foreignArgsLength: ForeignCallSingle,
     foreignArgs: ForeignCallArray,
     foreignArgsHash: ForeignCallSingle,
     foreignIsStaticCall: ForeignCallSingle,
@@ -881,7 +1005,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,27 +1014,30 @@ 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,
+    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(
     foreignFrom: ForeignCallSingle,
     foreignAddress: ForeignCallSingle,
-    _foreignLength: ForeignCallSingle,
     foreignCalldata: ForeignCallArray,
     foreignIsStaticCall: ForeignCallSingle,
   ) {
@@ -919,13 +1046,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 +1067,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)]);
+  }
 }