@aztec/txe 0.0.1-commit.c2eed6949 → 0.0.1-commit.c52d6e7

package/src/rpc_translator.ts

@@ -1,37 +1,9 @@
-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,
-  packAsHintedNote,
-} from '@aztec/pxe/simulator';
-import { type ContractArtifact, EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { BlockHash } from '@aztec/stdlib/block';
+import type { IMiscOracle, IPrivateExecutionOracle, IUtilityExecutionOracle } from '@aztec/pxe/simulator';
 
 import type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.js';
+import { callTxeHandler } from './oracle/txe_oracle_registry.js';
 import type { TXESessionStateHandler } from './txe_session.js';
-import {
-  type ForeignCallArray,
-  type ForeignCallSingle,
-  addressFromSingle,
-  arrayOfArraysToBoundedVecOfArrays,
-  arrayToBoundedVec,
-  bufferToU8Array,
-  fromArray,
-  fromSingle,
-  fromUintArray,
-  fromUintBoundedVec,
-  toArray,
-  toForeignCallResult,
-  toSingle,
-} from './util/encoding.js';
-
-const MAX_EVENT_LEN = 10; // This is MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN
-const MAX_PRIVATE_EVENTS_PER_TXE_QUERY = 5;
+import type { ForeignCallArgs } from './utils/encoding.js';
 
 export class UnavailableOracleError extends Error {
   constructor(oracleName: string) {
@@ -102,61 +74,54 @@ export class RPCTranslator {
     return this.oracleHandler;
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_txe_assertCompatibleOracleVersion(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_assertCompatibleOracleVersion',
+      inputs,
+      handler: ([major, minor]) => {
+        this.stateHandler.setTxeOracleVersion(major, minor);
+      },
+    });
+  }
+
   // TXE session state transition functions - these get handled by the state handler
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_setTopLevelTXEContext() {
-    await this.stateHandler.enterTopLevelState();
-
-    return toForeignCallResult([]);
+  aztec_txe_setTopLevelTXEContext() {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setTopLevelTXEContext',
+      inputs: [],
+      handler: () => this.stateHandler.enterTopLevelState(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_setPrivateTXEContext(
-    foreignContractAddressIsSome: ForeignCallSingle,
-    foreignContractAddressValue: ForeignCallSingle,
-    foreignAnchorBlockNumberIsSome: ForeignCallSingle,
-    foreignAnchorBlockNumberValue: ForeignCallSingle,
-  ) {
-    const contractAddress = fromSingle(foreignContractAddressIsSome).toBool()
-      ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
-      : undefined;
-
-    const anchorBlockNumber = fromSingle(foreignAnchorBlockNumberIsSome).toBool()
-      ? BlockNumber(fromSingle(foreignAnchorBlockNumberValue).toNumber())
-      : undefined;
-
-    const privateContextInputs = await this.stateHandler.enterPrivateState(contractAddress, anchorBlockNumber);
-
-    return toForeignCallResult(privateContextInputs.toFields().map(toSingle));
+  aztec_txe_setPrivateTXEContext(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setPrivateTXEContext',
+      inputs,
+      handler: ([contractAddress, anchorBlockNumber, gasSettings]) =>
+        this.stateHandler.enterPrivateState(contractAddress, anchorBlockNumber, gasSettings),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_setPublicTXEContext(
-    foreignContractAddressIsSome: ForeignCallSingle,
-    foreignContractAddressValue: ForeignCallSingle,
-  ) {
-    const contractAddress = fromSingle(foreignContractAddressIsSome).toBool()
-      ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
-      : undefined;
-
-    await this.stateHandler.enterPublicState(contractAddress);
-
-    return toForeignCallResult([]);
+  aztec_txe_setPublicTXEContext(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setPublicTXEContext',
+      inputs,
+      handler: ([contractAddress]) => this.stateHandler.enterPublicState(contractAddress),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_setUtilityTXEContext(
-    foreignContractAddressIsSome: ForeignCallSingle,
-    foreignContractAddressValue: ForeignCallSingle,
-  ) {
-    const contractAddress = fromSingle(foreignContractAddressIsSome).toBool()
-      ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
-      : undefined;
-
-    await this.stateHandler.enterUtilityState(contractAddress);
-
-    return toForeignCallResult([]);
+  aztec_txe_setUtilityTXEContext(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setUtilityTXEContext',
+      inputs,
+      handler: ([contractAddress]) => this.stateHandler.enterUtilityState(contractAddress),
+    });
   }
 
   // Other oracles - these get handled by the oracle handler
@@ -165,713 +130,690 @@ export class RPCTranslator {
 
   // eslint-disable-next-line camelcase
   aztec_txe_getDefaultAddress() {
-    const defaultAddress = this.handlerAsTxe().getDefaultAddress();
-
-    return toForeignCallResult([toSingle(defaultAddress)]);
+    return callTxeHandler({
+      oracle: 'aztec_txe_getDefaultAddress',
+      inputs: [],
+      handler: () => this.handlerAsTxe().getDefaultAddress(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_getNextBlockNumber() {
-    const nextBlockNumber = await this.handlerAsTxe().getNextBlockNumber();
-
-    return toForeignCallResult([toSingle(nextBlockNumber)]);
+  aztec_txe_getNextBlockNumber() {
+    return callTxeHandler({
+      oracle: 'aztec_txe_getNextBlockNumber',
+      inputs: [],
+      handler: () => this.handlerAsTxe().getNextBlockNumber(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_getNextBlockTimestamp() {
-    const nextBlockTimestamp = await this.handlerAsTxe().getNextBlockTimestamp();
-
-    return toForeignCallResult([toSingle(nextBlockTimestamp)]);
+  aztec_txe_getNextBlockTimestamp() {
+    return callTxeHandler({
+      oracle: 'aztec_txe_getNextBlockTimestamp',
+      inputs: [],
+      handler: () => this.handlerAsTxe().getNextBlockTimestamp(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_advanceBlocksBy(foreignBlocks: ForeignCallSingle) {
-    const blocks = fromSingle(foreignBlocks).toNumber();
-
-    await this.handlerAsTxe().advanceBlocksBy(blocks);
-
-    return toForeignCallResult([]);
+  aztec_txe_advanceBlocksBy(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_advanceBlocksBy',
+      inputs,
+      handler: ([blocks]) => this.handlerAsTxe().advanceBlocksBy(blocks),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_txe_advanceTimestampBy(foreignDuration: ForeignCallSingle) {
-    const duration = fromSingle(foreignDuration).toBigInt();
-
-    this.handlerAsTxe().advanceTimestampBy(duration);
-
-    return toForeignCallResult([]);
+  aztec_txe_advanceTimestampBy(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_advanceTimestampBy',
+      inputs,
+      handler: ([duration]) => this.handlerAsTxe().advanceTimestampBy(duration),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_deploy(
-    artifact: ContractArtifact,
-    instance: ContractInstanceWithAddress,
-    foreignSecret: ForeignCallSingle,
-  ) {
-    const secret = fromSingle(foreignSecret);
-
-    await this.handlerAsTxe().deploy(artifact, instance, secret);
-
-    return toForeignCallResult([
-      toArray([
-        instance.salt,
-        instance.deployer.toField(),
-        instance.currentContractClassId,
-        instance.initializationHash,
-        ...instance.publicKeys.toFields(),
-      ]),
-    ]);
+  aztec_txe_deploy(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_deploy',
+      inputs,
+      handler: ([contractPath, initializer, _, args, secret, salt, deployer]) =>
+        this.handlerAsTxe().deploy(contractPath, initializer, args, secret, salt, deployer),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_createAccount(foreignSecret: ForeignCallSingle) {
-    const secret = fromSingle(foreignSecret);
-
-    const completeAddress = await this.handlerAsTxe().createAccount(secret);
-
-    return toForeignCallResult([
-      toSingle(completeAddress.address),
-      ...completeAddress.publicKeys.toFields().map(toSingle),
-    ]);
+  aztec_txe_createAccount(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_createAccount',
+      inputs,
+      handler: ([secret, partialAddress]) => this.handlerAsTxe().createAccount(secret, partialAddress),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_addAccount(
-    artifact: ContractArtifact,
-    instance: ContractInstanceWithAddress,
-    foreignSecret: ForeignCallSingle,
-  ) {
-    const secret = fromSingle(foreignSecret);
-
-    const completeAddress = await this.handlerAsTxe().addAccount(artifact, instance, secret);
+  aztec_txe_addAccount(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_addAccount',
+      inputs,
+      handler: ([secret]) => this.handlerAsTxe().addAccount(secret),
+    });
+  }
 
-    return toForeignCallResult([
-      toSingle(completeAddress.address),
-      ...completeAddress.publicKeys.toFields().map(toSingle),
-    ]);
+  // eslint-disable-next-line camelcase
+  aztec_txe_addAuthWitness(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_addAuthWitness',
+      inputs,
+      handler: ([address, messageHash]) => this.handlerAsTxe().addAuthWitness(address, messageHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_addAuthWitness(foreignAddress: ForeignCallSingle, foreignMessageHash: ForeignCallSingle) {
-    const address = addressFromSingle(foreignAddress);
-    const messageHash = fromSingle(foreignMessageHash);
+  aztec_txe_sendL1ToL2Message(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_sendL1ToL2Message',
+      inputs,
+      handler: ([content, secretHash, sender, recipient]) =>
+        this.handlerAsTxe().sendL1ToL2Message(content, secretHash, sender, recipient),
+    });
+  }
 
-    await this.handlerAsTxe().addAuthWitness(address, messageHash);
+  // eslint-disable-next-line camelcase
+  aztec_txe_setTaggingSecretStrategies(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setTaggingSecretStrategies',
+      inputs,
+      handler: ([unconstrainedStrategy, constrainedStrategy]) =>
+        this.handlerAsTxe().setTaggingSecretStrategies(unconstrainedStrategy, constrainedStrategy),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_txe_setAuthorizeAllUtilityCallTargets(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setAuthorizeAllUtilityCallTargets',
+      inputs,
+      handler: ([authorizeAll]) => this.handlerAsTxe().setAuthorizeAllUtilityCallTargets(authorizeAll),
+    });
   }
 
   // PXE oracles
 
   // eslint-disable-next-line camelcase
-  aztec_utl_assertCompatibleOracleVersion(foreignVersion: ForeignCallSingle) {
-    const version = fromSingle(foreignVersion).toNumber();
-
-    this.handlerAsMisc().assertCompatibleOracleVersion(version);
-
-    return toForeignCallResult([]);
+  aztec_misc_assertCompatibleOracleVersion(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_misc_assertCompatibleOracleVersion',
+      inputs,
+      handler: ([major, minor]) => this.handlerAsMisc().assertCompatibleOracleVersion(major, minor),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_getRandomField() {
-    const randomField = this.handlerAsMisc().getRandomField();
-
-    return toForeignCallResult([toSingle(randomField)]);
+  aztec_misc_getRandomField() {
+    return callTxeHandler({
+      oracle: 'aztec_misc_getRandomField',
+      inputs: [],
+      handler: () => this.handlerAsMisc().getRandomField(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_getLastBlockTimestamp() {
-    const timestamp = await this.handlerAsTxe().getLastBlockTimestamp();
-
-    return toForeignCallResult([toSingle(new Fr(timestamp))]);
+  aztec_txe_getLastBlockTimestamp() {
+    return callTxeHandler({
+      oracle: 'aztec_txe_getLastBlockTimestamp',
+      inputs: [],
+      handler: () => this.handlerAsTxe().getLastBlockTimestamp(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_getLastTxEffects() {
-    const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().getLastTxEffects();
-
-    return toForeignCallResult([
-      toSingle(txHash.hash),
-      ...arrayToBoundedVec(toArray(noteHashes), MAX_NOTE_HASHES_PER_TX),
-      ...arrayToBoundedVec(toArray(nullifiers), MAX_NULLIFIERS_PER_TX),
-    ]);
+  aztec_txe_getLastTxEffects() {
+    return callTxeHandler({
+      oracle: 'aztec_txe_getLastTxEffects',
+      inputs: [],
+      handler: () => this.handlerAsTxe().getLastTxEffects(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_txe_getPrivateEvents(
-    foreignSelector: ForeignCallSingle,
-    foreignContractAddress: ForeignCallSingle,
-    foreignScope: ForeignCallSingle,
-  ) {
-    const selector = EventSelector.fromField(fromSingle(foreignSelector));
-    const contractAddress = addressFromSingle(foreignContractAddress);
-    const scope = addressFromSingle(foreignScope);
-
-    // TODO(F-335): Avoid doing the following 2 calls here.
-    {
-      await this.handlerAsTxe().syncContractNonOracleMethod(contractAddress, scope, this.stateHandler.getCurrentJob());
-      // We cycle job to commit the stores after the contract sync.
-      await this.stateHandler.cycleJob();
-    }
-
-    const events = await this.handlerAsTxe().getPrivateEvents(selector, contractAddress, scope);
-
-    if (events.length > MAX_PRIVATE_EVENTS_PER_TXE_QUERY) {
-      throw new Error(`Array of length ${events.length} larger than maxLen ${MAX_PRIVATE_EVENTS_PER_TXE_QUERY}`);
-    }
-
-    if (events.some(e => e.length > MAX_EVENT_LEN)) {
-      throw new Error(`Some private event has length larger than maxLen ${MAX_EVENT_LEN}`);
-    }
-
-    // This is a workaround as Noir does not currently let us return nested structs with arrays. We instead return a raw
-    // multidimensional array in get_private_events_oracle and create the BoundedVecs here.
-    const rawArrayStorage = events
-      .map(e => e.concat(Array(MAX_EVENT_LEN - e.length).fill(new Fr(0))))
-      .concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(Array(MAX_EVENT_LEN).fill(new Fr(0))))
-      .flat();
-    const eventLengths = events
-      .map(e => new Fr(e.length))
-      .concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(new Fr(0)));
-    const queryLength = new Fr(events.length);
-
-    return toForeignCallResult([toArray(rawArrayStorage), toArray(eventLengths), toSingle(queryLength)]);
+  aztec_txe_getLastCallOffchainEffects() {
+    return callTxeHandler({
+      oracle: 'aztec_txe_getLastCallOffchainEffects',
+      inputs: [],
+      handler: () => this.stateHandler.getLastCallOffchainEffects(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_prv_storeInExecutionCache(foreignValues: ForeignCallArray, foreignHash: ForeignCallSingle) {
-    const values = fromArray(foreignValues);
-    const hash = fromSingle(foreignHash);
-
-    this.handlerAsPrivate().storeInExecutionCache(values, hash);
-
-    return toForeignCallResult([]);
+  aztec_txe_getLastCallContext() {
+    return callTxeHandler({
+      oracle: 'aztec_txe_getLastCallContext',
+      inputs: [],
+      handler: () => this.stateHandler.getLastCallContext(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_loadFromExecutionCache(foreignHash: ForeignCallSingle) {
-    const hash = fromSingle(foreignHash);
-
-    const returns = await this.handlerAsPrivate().loadFromExecutionCache(hash);
-
-    return toForeignCallResult([toArray(returns)]);
+  aztec_txe_getPrivateEvents(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_getPrivateEvents',
+      inputs,
+      handler: ([selector, contractAddress, scope]) =>
+        this.stateHandler.getPrivateEvents(selector, contractAddress, scope),
+    });
   }
 
-  // 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.
   // eslint-disable-next-line camelcase
-  async aztec_utl_log(
-    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);
-
-    await this.handlerAsMisc().log(level, message, fields);
-
-    return toForeignCallResult([]);
+  aztec_prv_setHashPreimage(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_setHashPreimage',
+      inputs,
+      handler: ([values, hash]) => this.handlerAsPrivate().setHashPreimage(values, hash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_storageRead(
-    foreignBlockHash: ForeignCallSingle,
-    foreignContractAddress: ForeignCallSingle,
-    foreignStartStorageSlot: ForeignCallSingle,
-    foreignNumberOfElements: ForeignCallSingle,
-  ) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
-    const contractAddress = addressFromSingle(foreignContractAddress);
-    const startStorageSlot = fromSingle(foreignStartStorageSlot);
-    const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
-
-    const values = await this.handlerAsUtility().storageRead(
-      blockHash,
-      contractAddress,
-      startStorageSlot,
-      numberOfElements,
-    );
-
-    return toForeignCallResult([toArray(values)]);
+  aztec_prv_getHashPreimage(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_getHashPreimage',
+      inputs,
+      handler: ([hash]) => this.handlerAsPrivate().getHashPreimage(hash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getPublicDataWitness(foreignBlockHash: ForeignCallSingle, foreignLeafSlot: ForeignCallSingle) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
-    const leafSlot = fromSingle(foreignLeafSlot);
-
-    const witness = await this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot);
-
-    if (!witness) {
-      throw new Error(`Public data witness not found for slot ${leafSlot} at block ${blockHash.toString()}.`);
-    }
-    return toForeignCallResult(witness.toNoirRepresentation());
-  }
-
-  // eslint-disable-next-line camelcase
-  async aztec_utl_getNotes(
-    foreignOwnerIsSome: ForeignCallSingle,
-    foreignOwnerValue: ForeignCallSingle,
-    foreignStorageSlot: ForeignCallSingle,
-    foreignNumSelects: ForeignCallSingle,
-    foreignSelectByIndexes: ForeignCallArray,
-    foreignSelectByOffsets: ForeignCallArray,
-    foreignSelectByLengths: ForeignCallArray,
-    foreignSelectValues: ForeignCallArray,
-    foreignSelectComparators: ForeignCallArray,
-    foreignSortByIndexes: ForeignCallArray,
-    foreignSortByOffsets: ForeignCallArray,
-    foreignSortByLengths: ForeignCallArray,
-    foreignSortOrder: ForeignCallArray,
-    foreignLimit: ForeignCallSingle,
-    foreignOffset: ForeignCallSingle,
-    foreignStatus: ForeignCallSingle,
-    foreignMaxNotes: ForeignCallSingle,
-    foreignPackedHintedNoteLength: 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());
-    const selectByOffsets = fromArray(foreignSelectByOffsets).map(fr => fr.toNumber());
-    const selectByLengths = fromArray(foreignSelectByLengths).map(fr => fr.toNumber());
-    const selectValues = fromArray(foreignSelectValues);
-    const selectComparators = fromArray(foreignSelectComparators).map(fr => fr.toNumber());
-    const sortByIndexes = fromArray(foreignSortByIndexes).map(fr => fr.toNumber());
-    const sortByOffsets = fromArray(foreignSortByOffsets).map(fr => fr.toNumber());
-    const sortByLengths = fromArray(foreignSortByLengths).map(fr => fr.toNumber());
-    const sortOrder = fromArray(foreignSortOrder).map(fr => fr.toNumber());
-    const limit = fromSingle(foreignLimit).toNumber();
-    const offset = fromSingle(foreignOffset).toNumber();
-    const status = fromSingle(foreignStatus).toNumber();
-    const maxNotes = fromSingle(foreignMaxNotes).toNumber();
-    const packedHintedNoteLength = fromSingle(foreignPackedHintedNoteLength).toNumber();
-
-    const noteDatas = await this.handlerAsUtility().getNotes(
-      owner,
-      storageSlot,
-      numSelects,
-      selectByIndexes,
-      selectByOffsets,
-      selectByLengths,
-      selectValues,
-      selectComparators,
-      sortByIndexes,
-      sortByOffsets,
-      sortByLengths,
-      sortOrder,
-      limit,
-      offset,
-      status,
-    );
-
-    const returnDataAsArrayOfArrays = noteDatas.map(noteData =>
-      packAsHintedNote({
-        contractAddress: noteData.contractAddress,
-        owner: noteData.owner,
-        randomness: noteData.randomness,
-        storageSlot: noteData.storageSlot,
-        noteNonce: noteData.noteNonce,
-        isPending: noteData.isPending,
-        note: noteData.note,
-      }),
-    );
-
-    // Now we convert each sub-array to an array of ForeignCallSingles
-    const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map(subArray =>
-      subArray.map(toSingle),
-    );
-
-    // At last we convert the array of arrays to a bounded vec of arrays
-    return toForeignCallResult(
-      arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfForeignCallSingleArrays, maxNotes, packedHintedNoteLength),
-    );
-  }
-
-  // eslint-disable-next-line camelcase
-  aztec_prv_notifyCreatedNote(
-    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.handlerAsPrivate().notifyCreatedNote(owner, storageSlot, randomness, noteTypeId, note, noteHash, counter);
-
-    return toForeignCallResult([]);
-  }
-
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifyNullifiedNote(
-    foreignInnerNullifier: ForeignCallSingle,
-    foreignNoteHash: ForeignCallSingle,
-    foreignCounter: ForeignCallSingle,
-  ) {
-    const innerNullifier = fromSingle(foreignInnerNullifier);
-    const noteHash = fromSingle(foreignNoteHash);
-    const counter = fromSingle(foreignCounter).toNumber();
-
-    await this.handlerAsPrivate().notifyNullifiedNote(innerNullifier, noteHash, counter);
-
-    return toForeignCallResult([]);
-  }
-
-  // eslint-disable-next-line camelcase
-  async aztec_prv_notifyCreatedNullifier(foreignInnerNullifier: ForeignCallSingle) {
-    const innerNullifier = fromSingle(foreignInnerNullifier);
-
-    await this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier);
-
-    return toForeignCallResult([]);
+  aztec_misc_log(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_misc_log',
+      inputs,
+      handler: ([level, message, fieldsSize, fields]) => this.handlerAsMisc().log(level, message, fieldsSize, fields),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_isNullifierPending(
-    foreignInnerNullifier: ForeignCallSingle,
-    foreignContractAddress: ForeignCallSingle,
-  ) {
-    const innerNullifier = fromSingle(foreignInnerNullifier);
-    const contractAddress = addressFromSingle(foreignContractAddress);
-
-    const isPending = await this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress);
-
-    return toForeignCallResult([toSingle(new Fr(isPending))]);
+  aztec_utl_getFromPublicStorage(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getFromPublicStorage',
+      inputs,
+      handler: ([blockHash, contractAddress, startStorageSlot, numberOfElements]) =>
+        this.handlerAsUtility().getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_checkNullifierExists(foreignInnerNullifier: ForeignCallSingle) {
-    const innerNullifier = fromSingle(foreignInnerNullifier);
-
-    const exists = await this.handlerAsUtility().checkNullifierExists(innerNullifier);
-
-    return toForeignCallResult([toSingle(new Fr(exists))]);
+  aztec_utl_getPublicDataWitness(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getPublicDataWitness',
+      inputs,
+      handler: ([blockHash, leafSlot]) => this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getContractInstance(foreignAddress: ForeignCallSingle) {
-    const address = addressFromSingle(foreignAddress);
-
-    const instance = await this.handlerAsUtility().getContractInstance(address);
-
-    return toForeignCallResult(
-      [
-        instance.salt,
-        instance.deployer.toField(),
-        instance.currentContractClassId,
-        instance.initializationHash,
-        ...instance.publicKeys.toFields(),
-      ].map(toSingle),
-    );
+  aztec_utl_getNotes(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getNotes',
+      inputs,
+      handler: ([
+        owner,
+        storageSlot,
+        numSelects,
+        selectByIndexes,
+        selectByOffsets,
+        selectByLengths,
+        selectValues,
+        selectComparators,
+        sortByIndexes,
+        sortByOffsets,
+        sortByLengths,
+        sortOrder,
+        limit,
+        offset,
+        status,
+        maxNotes,
+        packedHintedNoteLength,
+      ]) =>
+        this.handlerAsUtility().getNotes(
+          owner,
+          storageSlot,
+          numSelects,
+          selectByIndexes,
+          selectByOffsets,
+          selectByLengths,
+          selectValues,
+          selectComparators,
+          sortByIndexes,
+          sortByOffsets,
+          sortByLengths,
+          sortOrder,
+          limit,
+          offset,
+          status,
+          maxNotes,
+          packedHintedNoteLength,
+        ),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_tryGetPublicKeysAndPartialAddress(foreignAddress: ForeignCallSingle) {
-    const address = addressFromSingle(foreignAddress);
-
-    const result = await this.handlerAsUtility().tryGetPublicKeysAndPartialAddress(address);
+  aztec_prv_notifyCreatedNote(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_notifyCreatedNote',
+      inputs,
+      handler: ([owner, storageSlot, randomness, noteTypeId, note, noteHash, counter]) =>
+        this.handlerAsPrivate().notifyCreatedNote(owner, storageSlot, randomness, noteTypeId, note, noteHash, counter),
+    });
+  }
 
-    // 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 (result === undefined) {
-      // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
-      return toForeignCallResult([toSingle(new Fr(0)), toArray(Array(13).fill(new Fr(0)))]);
-    } else {
-      // Data was found so we set `some` to 1 and return it along with `value`.
-      return toForeignCallResult([
-        toSingle(new Fr(1)),
-        toArray([...result.publicKeys.toFields(), result.partialAddress]),
-      ]);
-    }
+  // eslint-disable-next-line camelcase
+  aztec_prv_notifyNullifiedNote(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_notifyNullifiedNote',
+      inputs,
+      handler: ([innerNullifier, noteHash, counter]) =>
+        this.handlerAsPrivate().notifyNullifiedNote(innerNullifier, noteHash, counter),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getKeyValidationRequest(foreignPkMHash: ForeignCallSingle) {
-    const pkMHash = fromSingle(foreignPkMHash);
+  aztec_prv_notifyCreatedNullifier(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_notifyCreatedNullifier',
+      inputs,
+      handler: ([innerNullifier]) => this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier),
+    });
+  }
 
-    const keyValidationRequest = await this.handlerAsUtility().getKeyValidationRequest(pkMHash);
+  // eslint-disable-next-line camelcase
+  aztec_prv_isNullifierPending(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_isNullifierPending',
+      inputs,
+      handler: ([innerNullifier, contractAddress]) =>
+        this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress),
+    });
+  }
 
-    return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
+  // eslint-disable-next-line camelcase
+  aztec_utl_doesNullifierExist(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_doesNullifierExist',
+      inputs,
+      handler: ([innerNullifier]) => this.handlerAsUtility().doesNullifierExist(innerNullifier),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_prv_callPrivateFunction(
-    _foreignTargetContractAddress: ForeignCallSingle,
-    _foreignFunctionSelector: ForeignCallSingle,
-    _foreignArgsHash: ForeignCallSingle,
-    _foreignSideEffectCounter: ForeignCallSingle,
-    _foreignIsStaticCall: ForeignCallSingle,
-  ) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::private_context`, use `private_call` instead',
-    );
+  aztec_utl_getContractInstance(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getContractInstance',
+      inputs,
+      handler: ([address]) => this.handlerAsUtility().getContractInstance(address),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getNullifierMembershipWitness(
-    foreignBlockHash: ForeignCallSingle,
-    foreignNullifier: ForeignCallSingle,
-  ) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
-    const nullifier = fromSingle(foreignNullifier);
+  aztec_utl_getPublicKeysAndPartialAddress(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getPublicKeysAndPartialAddress',
+      inputs,
+      handler: ([address]) => this.handlerAsUtility().getPublicKeysAndPartialAddress(address),
+    });
+  }
 
-    const witness = await this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getKeyValidationRequest(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getKeyValidationRequest',
+      inputs,
+      handler: ([pkMHash, keyIndex]) => this.handlerAsUtility().getKeyValidationRequest(pkMHash, keyIndex),
+    });
+  }
 
-    if (!witness) {
-      throw new Error(`Nullifier membership witness not found at block ${blockHash}.`);
-    }
-    return toForeignCallResult(witness.toNoirRepresentation());
+  // eslint-disable-next-line camelcase
+  aztec_prv_callPrivateFunction(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_callPrivateFunction',
+      inputs,
+      handler: ([contractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall]) =>
+        this.handlerAsPrivate().callPrivateFunction(
+          contractAddress,
+          functionSelector,
+          argsHash,
+          sideEffectCounter,
+          isStaticCall,
+        ),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getAuthWitness(foreignMessageHash: ForeignCallSingle) {
-    const messageHash = fromSingle(foreignMessageHash);
+  aztec_utl_getNullifierMembershipWitness(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getNullifierMembershipWitness',
+      inputs,
+      handler: ([blockHash, nullifier]) => this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier),
+    });
+  }
 
-    const authWitness = await this.handlerAsUtility().getAuthWitness(messageHash);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getL1ToL2MembershipWitnessV2(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getL1ToL2MembershipWitnessV2',
+      inputs,
+      handler: ([messageHash, nullifier]) =>
+        this.handlerAsUtility().getL1ToL2MembershipWitnessV2(messageHash, nullifier),
+    });
+  }
 
-    if (!authWitness) {
-      throw new Error(`Auth witness not found for message hash ${messageHash}.`);
-    }
-    return toForeignCallResult([toArray(authWitness)]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getAuthWitness(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getAuthWitness',
+      inputs,
+      handler: ([messageHash]) => this.handlerAsUtility().getAuthWitness(messageHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  public aztec_prv_validatePublicCalldata(_foreignCalldataHash: ForeignCallSingle) {
-    throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+  aztec_prv_assertValidPublicCalldata(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_assertValidPublicCalldata',
+      inputs,
+      handler: ([calldataHash]) => this.handlerAsPrivate().assertValidPublicCalldata(calldataHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  public aztec_prv_notifyRevertiblePhaseStart(_foreignMinRevertibleSideEffectCounter: ForeignCallSingle) {
-    throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+  aztec_prv_notifyRevertiblePhaseStart(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_notifyRevertiblePhaseStart',
+      inputs,
+      handler: ([minRevertibleSideEffectCounter]) =>
+        this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_prv_inRevertiblePhase(foreignSideEffectCounter: ForeignCallSingle) {
-    const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
-    const isRevertible = await this.handlerAsPrivate().inRevertiblePhase(sideEffectCounter);
-    return toForeignCallResult([toSingle(new Fr(isRevertible))]);
+  aztec_prv_isExecutionInRevertiblePhase(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_isExecutionInRevertiblePhase',
+      inputs,
+      handler: ([sideEffectCounter]) => this.handlerAsPrivate().isExecutionInRevertiblePhase(sideEffectCounter),
+    });
   }
 
   // eslint-disable-next-line camelcase
   aztec_utl_getUtilityContext() {
-    const context = this.handlerAsUtility().getUtilityContext();
-
-    return toForeignCallResult(context.toNoirRepresentation());
+    return callTxeHandler({
+      oracle: 'aztec_utl_getUtilityContext',
+      inputs: [],
+      handler: () => this.handlerAsUtility().getUtilityContext(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getBlockHeader(foreignBlockNumber: ForeignCallSingle) {
-    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
-
-    const header = await this.handlerAsUtility().getBlockHeader(blockNumber);
-
-    if (!header) {
-      throw new Error(`Block header not found for block ${blockNumber}.`);
-    }
-    return toForeignCallResult(header.toFields().map(toSingle));
+  aztec_utl_getBlockHeader(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getBlockHeader',
+      inputs,
+      handler: ([blockNumber]) => this.handlerAsUtility().getBlockHeader(blockNumber),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getNoteHashMembershipWitness(
-    foreignAnchorBlockHash: ForeignCallSingle,
-    foreignNoteHash: ForeignCallSingle,
-  ) {
-    const blockHash = new BlockHash(fromSingle(foreignAnchorBlockHash));
-    const noteHash = fromSingle(foreignNoteHash);
-
-    const witness = await this.handlerAsUtility().getNoteHashMembershipWitness(blockHash, noteHash);
-
-    if (!witness) {
-      throw new Error(`Note hash ${noteHash} not found in the note hash tree at block ${blockHash.toString()}.`);
-    }
-    return toForeignCallResult(witness.toNoirRepresentation());
+  aztec_utl_getNoteHashMembershipWitness(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getNoteHashMembershipWitness',
+      inputs,
+      handler: ([blockHash, noteHash]) => this.handlerAsUtility().getNoteHashMembershipWitness(blockHash, noteHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getBlockHashMembershipWitness(
-    foreignAnchorBlockHash: ForeignCallSingle,
-    foreignBlockHash: ForeignCallSingle,
-  ) {
-    const anchorBlockHash = new BlockHash(fromSingle(foreignAnchorBlockHash));
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
-
-    const witness = await this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash);
-
-    if (!witness) {
-      throw new Error(
-        `Block hash ${blockHash.toString()} not found in the archive tree at anchor block ${anchorBlockHash.toString()}.`,
-      );
-    }
-    return toForeignCallResult(witness.toNoirRepresentation());
+  aztec_utl_getBlockHashMembershipWitness(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getBlockHashMembershipWitness',
+      inputs,
+      handler: ([anchorBlockHash, blockHash]) =>
+        this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getLowNullifierMembershipWitness(
-    foreignBlockHash: ForeignCallSingle,
-    foreignNullifier: ForeignCallSingle,
-  ) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
-    const nullifier = fromSingle(foreignNullifier);
-
-    const witness = await this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier);
-
-    if (!witness) {
-      throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockHash}.`);
-    }
-    return toForeignCallResult(witness.toNoirRepresentation());
+  aztec_utl_areBlockHashesInArchive(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_areBlockHashesInArchive',
+      inputs,
+      handler: ([anchorBlockHash, blockHashes]) =>
+        this.handlerAsUtility().areBlockHashesInArchive(anchorBlockHash, blockHashes),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_fetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot: ForeignCallSingle) {
-    const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
+  aztec_utl_getLowNullifierMembershipWitness(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getLowNullifierMembershipWitness',
+      inputs,
+      handler: ([blockHash, nullifier]) =>
+        this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier),
+    });
+  }
 
-    await this.handlerAsUtility().fetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getPendingTaggedLogsV2(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getPendingTaggedLogsV2',
+      inputs,
+      handler: ([scope, providedSecrets]) => this.handlerAsUtility().getPendingTaggedLogsV2(scope, providedSecrets),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_validateAndStoreEnqueuedNotesAndEvents(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_validateAndStoreEnqueuedNotesAndEvents',
+      inputs,
+      handler: ([noteValidationRequests, eventValidationRequests, scope]) =>
+        this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
+          noteValidationRequests,
+          eventValidationRequests,
+          scope,
+        ),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(
-    foreignContractAddress: ForeignCallSingle,
-    foreignNoteValidationRequestsArrayBaseSlot: ForeignCallSingle,
-    foreignEventValidationRequestsArrayBaseSlot: ForeignCallSingle,
-    foreignMaxNotePackedLen: ForeignCallSingle,
-    foreignMaxEventSerializedLen: ForeignCallSingle,
-  ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
-    const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
-    const maxNotePackedLen = fromSingle(foreignMaxNotePackedLen).toNumber();
-    const maxEventSerializedLen = fromSingle(foreignMaxEventSerializedLen).toNumber();
+  aztec_utl_getLogsByTagV2(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getLogsByTagV2',
+      inputs,
+      handler: ([requestArrayBaseSlot]) => this.handlerAsUtility().getLogsByTagV2(requestArrayBaseSlot),
+    });
+  }
 
-    await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
-      contractAddress,
-      noteValidationRequestsArrayBaseSlot,
-      eventValidationRequestsArrayBaseSlot,
-      maxNotePackedLen,
-      maxEventSerializedLen,
-    );
+  // eslint-disable-next-line camelcase
+  aztec_utl_getResolvedTxs(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getResolvedTxs',
+      inputs,
+      handler: ([requestArrayBaseSlot]) => this.handlerAsUtility().getResolvedTxs(requestArrayBaseSlot),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getTxEffects(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getTxEffects',
+      inputs,
+      handler: ([txHashes]) => this.handlerAsUtility().getTxEffects(txHashes),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_utl_bulkRetrieveLogs(
-    foreignContractAddress: ForeignCallSingle,
-    foreignLogRetrievalRequestsArrayBaseSlot: ForeignCallSingle,
-    foreignLogRetrievalResponsesArrayBaseSlot: ForeignCallSingle,
-  ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
-    const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
+  aztec_utl_setCapsule(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_setCapsule',
+      inputs,
+      handler: ([contractAddress, slot, capsule, scope]) =>
+        this.handlerAsUtility().setCapsule(contractAddress, slot, capsule, scope),
+    });
+  }
 
-    await this.handlerAsUtility().bulkRetrieveLogs(
-      contractAddress,
-      logRetrievalRequestsArrayBaseSlot,
-      logRetrievalResponsesArrayBaseSlot,
-    );
+  // eslint-disable-next-line camelcase
+  aztec_utl_getCapsule(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getCapsule',
+      inputs,
+      handler: ([contractAddress, slot, tSize, scope]) =>
+        this.handlerAsUtility().getCapsule(contractAddress, slot, tSize, scope),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_deleteCapsule(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_deleteCapsule',
+      inputs,
+      handler: ([contractAddress, slot, scope]) => this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_utl_utilityResolveMessageContexts(
-    foreignContractAddress: ForeignCallSingle,
-    foreignMessageContextRequestsArrayBaseSlot: ForeignCallSingle,
-    foreignMessageContextResponsesArrayBaseSlot: ForeignCallSingle,
-  ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const messageContextRequestsArrayBaseSlot = fromSingle(foreignMessageContextRequestsArrayBaseSlot);
-    const messageContextResponsesArrayBaseSlot = fromSingle(foreignMessageContextResponsesArrayBaseSlot);
+  aztec_utl_copyCapsule(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_copyCapsule',
+      inputs,
+      handler: ([contractAddress, srcSlot, dstSlot, numEntries, scope]) =>
+        this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, scope),
+    });
+  }
 
-    await this.handlerAsUtility().utilityResolveMessageContexts(
-      contractAddress,
-      messageContextRequestsArrayBaseSlot,
-      messageContextResponsesArrayBaseSlot,
-    );
+  // eslint-disable-next-line camelcase
+  aztec_utl_pushEphemeral(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_pushEphemeral',
+      inputs,
+      handler: ([slot, elements]) => this.handlerAsUtility().pushEphemeral(slot, elements),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_popEphemeral(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_popEphemeral',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().popEphemeral(slot),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_storeCapsule(
-    foreignContractAddress: ForeignCallSingle,
-    foreignSlot: ForeignCallSingle,
-    foreignCapsule: ForeignCallArray,
-  ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const slot = fromSingle(foreignSlot);
-    const capsule = fromArray(foreignCapsule);
+  aztec_utl_getEphemeral(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getEphemeral',
+      inputs,
+      handler: ([slot, index]) => this.handlerAsUtility().getEphemeral(slot, index),
+    });
+  }
 
-    await this.handlerAsUtility().storeCapsule(contractAddress, slot, capsule);
+  // eslint-disable-next-line camelcase
+  aztec_utl_setEphemeral(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_setEphemeral',
+      inputs,
+      handler: ([slot, index, elements]) => this.handlerAsUtility().setEphemeral(slot, index, elements),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getEphemeralLen(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getEphemeralLen',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().getEphemeralLen(slot),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_loadCapsule(
-    foreignContractAddress: ForeignCallSingle,
-    foreignSlot: ForeignCallSingle,
-    foreignTSize: ForeignCallSingle,
-  ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const slot = fromSingle(foreignSlot);
-    const tSize = fromSingle(foreignTSize).toNumber();
+  aztec_utl_removeEphemeral(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_removeEphemeral',
+      inputs,
+      handler: ([slot, index]) => this.handlerAsUtility().removeEphemeral(slot, index),
+    });
+  }
 
-    const values = await this.handlerAsUtility().loadCapsule(contractAddress, slot);
+  // eslint-disable-next-line camelcase
+  aztec_utl_clearEphemeral(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_clearEphemeral',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().clearEphemeral(slot),
+    });
+  }
 
-    // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
-    // with two fields: `some` (a boolean) and `value` (a field array in this case).
-    if (values === null) {
-      // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
-      return toForeignCallResult([toSingle(new Fr(0)), toArray(Array(tSize).fill(new Fr(0)))]);
-    } else {
-      // Data was found so we set `some` to 1 and return it along with `value`.
-      return toForeignCallResult([toSingle(new Fr(1)), toArray(values)]);
-    }
+  // eslint-disable-next-line camelcase
+  aztec_utl_pushTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_pushTransient',
+      inputs,
+      handler: ([slot, elements]) => this.handlerAsUtility().pushTransient(slot, elements),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_deleteCapsule(foreignContractAddress: ForeignCallSingle, foreignSlot: ForeignCallSingle) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const slot = fromSingle(foreignSlot);
+  aztec_utl_popTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_popTransient',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().popTransient(slot),
+    });
+  }
 
-    await this.handlerAsUtility().deleteCapsule(contractAddress, slot);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getTransient',
+      inputs,
+      handler: ([slot, index]) => this.handlerAsUtility().getTransient(slot, index),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_setTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_setTransient',
+      inputs,
+      handler: ([slot, index, elements]) => this.handlerAsUtility().setTransient(slot, index, elements),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_copyCapsule(
-    foreignContractAddress: ForeignCallSingle,
-    foreignSrcSlot: ForeignCallSingle,
-    foreignDstSlot: ForeignCallSingle,
-    foreignNumEntries: ForeignCallSingle,
-  ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const srcSlot = fromSingle(foreignSrcSlot);
-    const dstSlot = fromSingle(foreignDstSlot);
-    const numEntries = fromSingle(foreignNumEntries).toNumber();
+  aztec_utl_getTransientLen(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getTransientLen',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().getTransientLen(slot),
+    });
+  }
 
-    await this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+  // eslint-disable-next-line camelcase
+  aztec_utl_removeTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_removeTransient',
+      inputs,
+      handler: ([slot, index]) => this.handlerAsUtility().removeTransient(slot, index),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_clearTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_clearTransient',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().clearTransient(slot),
+    });
   }
 
   // TODO: I forgot to add a corresponding function here, when I introduced an oracle method to txe_oracle.ts.
@@ -879,363 +821,409 @@ export class RPCTranslator {
   // to implement this function here. Isn't there a way to programmatically identify that this is missing, given the
   // existence of a txe_oracle method?
   // eslint-disable-next-line camelcase
-  async aztec_utl_tryAes128Decrypt(
-    foreignCiphertextBVecStorage: ForeignCallArray,
-    foreignCiphertextLength: ForeignCallSingle,
-    foreignIv: ForeignCallArray,
-    foreignSymKey: ForeignCallArray,
-  ) {
-    const ciphertext = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
-    const iv = fromUintArray(foreignIv, 8);
-    const symKey = fromUintArray(foreignSymKey, 8);
-
-    // Noir Option<BoundedVec> is encoded as [is_some: Field, storage: Field[], length: Field].
-    try {
-      const plaintextBuffer = await this.handlerAsUtility().aes128Decrypt(ciphertext, iv, symKey);
-      const [storage, length] = arrayToBoundedVec(
-        bufferToU8Array(plaintextBuffer),
-        foreignCiphertextBVecStorage.length,
-      );
-      return toForeignCallResult([toSingle(new Fr(1)), storage, length]);
-    } catch {
-      const zeroStorage = toArray(Array(foreignCiphertextBVecStorage.length).fill(new Fr(0)));
-      return toForeignCallResult([toSingle(new Fr(0)), zeroStorage, toSingle(new Fr(0))]);
-    }
+  aztec_utl_decryptAes128(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_decryptAes128',
+      inputs,
+      handler: ([ciphertext, iv, symKey]) => this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getSharedSecret(
-    foreignAddress: ForeignCallSingle,
-    foreignEphPKField0: ForeignCallSingle,
-    foreignEphPKField1: ForeignCallSingle,
-    foreignEphPKField2: ForeignCallSingle,
-  ) {
-    const address = AztecAddress.fromField(fromSingle(foreignAddress));
-    const ephPK = Point.fromFields([
-      fromSingle(foreignEphPKField0),
-      fromSingle(foreignEphPKField1),
-      fromSingle(foreignEphPKField2),
-    ]);
-
-    const secret = await this.handlerAsUtility().getSharedSecret(address, ephPK);
-
-    return toForeignCallResult(secret.toFields().map(toSingle));
+  aztec_utl_getSharedSecrets(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getSharedSecrets',
+      inputs,
+      handler: ([address, ephPksSlot, contractAddress]) =>
+        this.handlerAsUtility().getSharedSecrets(address, ephPksSlot, contractAddress),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_invalidateContractSyncCache(
-    foreignContractAddress: ForeignCallSingle,
-    foreignScopes: ForeignCallArray,
-    foreignScopeCount: ForeignCallSingle,
-  ) {
-    const contractAddress = addressFromSingle(foreignContractAddress);
-    const count = fromSingle(foreignScopeCount).toNumber();
-    const scopes = fromArray(foreignScopes)
-      .slice(0, count)
-      .map(f => new AztecAddress(f));
-
-    this.handlerAsUtility().invalidateContractSyncCache(contractAddress, scopes);
-
-    return Promise.resolve(toForeignCallResult([]));
+  aztec_utl_setContractSyncCacheInvalid(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_setContractSyncCacheInvalid',
+      inputs,
+      handler: ([contractAddress, scopes]) =>
+        this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_emitOffchainEffect(_foreignData: ForeignCallArray) {
-    throw new Error('Offchain effects are not yet supported in the TestEnvironment');
+  aztec_utl_emitOffchainEffect(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_emitOffchainEffect',
+      inputs,
+      handler: ([data]) => {
+        // Record the raw payload against the currently-executing top-level call. The Noir side
+        // (via `env.offchain_messages()`) is responsible for decoding the protocol-reserved prefix
+        // (`OFFCHAIN_MESSAGE_IDENTIFIER`, recipient) and turning each payload into an `OffchainMessage` struct suitable
+        // for `offchain_receive`.
+        this.stateHandler.recordOffchainEffect(data);
+      },
+    });
   }
 
-  // AVM opcodes
-
   // eslint-disable-next-line camelcase
-  aztec_avm_emitPublicLog(_foreignMessage: ForeignCallArray) {
-    // TODO(#8811): Implement
-    return toForeignCallResult([]);
+  aztec_utl_recordFact(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_recordFact',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId, factTypeId, payload, originBlock]) =>
+        this.handlerAsUtility().recordFact(
+          contractAddress,
+          scope,
+          factCollectionTypeId,
+          factCollectionId,
+          factTypeId,
+          payload,
+          originBlock,
+        ),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_storageRead(foreignSlot: ForeignCallSingle, foreignContractAddress: ForeignCallSingle) {
-    const slot = fromSingle(foreignSlot);
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-
-    const value = (await this.handlerAsAvm().storageRead(slot, contractAddress)).value;
-
-    return toForeignCallResult([toSingle(new Fr(value))]);
+  aztec_utl_deleteFactCollection(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_deleteFactCollection',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId]) =>
+        this.handlerAsUtility().deleteFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_storageWrite(foreignSlot: ForeignCallSingle, foreignValue: ForeignCallSingle) {
-    const slot = fromSingle(foreignSlot);
-    const value = fromSingle(foreignValue);
-
-    await this.handlerAsAvm().storageWrite(slot, value);
-
-    return toForeignCallResult([]);
+  aztec_utl_getFactCollection(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getFactCollection',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId]) =>
+        this.handlerAsUtility().getFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_getContractInstanceDeployer(foreignAddress: ForeignCallSingle) {
-    const address = addressFromSingle(foreignAddress);
-
-    const instance = await this.handlerAsUtility().getContractInstance(address);
-
-    return toForeignCallResult([
-      toSingle(instance.deployer),
-      // AVM requires an extra boolean indicating the instance was found
-      toSingle(new Fr(1)),
-    ]);
+  aztec_utl_getFactCollectionsByType(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getFactCollectionsByType',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId]) =>
+        this.handlerAsUtility().getFactCollectionsByType(contractAddress, scope, factCollectionTypeId),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_getContractInstanceClassId(foreignAddress: ForeignCallSingle) {
-    const address = addressFromSingle(foreignAddress);
+  aztec_utl_callUtilityFunction(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_callUtilityFunction',
+      inputs,
+      handler: ([contractAddress, functionSelector, args]) =>
+        this.handlerAsUtility().callUtilityFunction(contractAddress, functionSelector, args),
+    });
+  }
 
-    const instance = await this.handlerAsUtility().getContractInstance(address);
+  // AVM opcodes
 
-    return toForeignCallResult([
-      toSingle(instance.currentContractClassId),
-      // AVM requires an extra boolean indicating the instance was found
-      toSingle(new Fr(1)),
-    ]);
+  // eslint-disable-next-line camelcase
+  aztec_avm_emitPublicLog() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_emitPublicLog',
+      inputs: [],
+      // TODO(#8811): Implement
+      handler: () => {},
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_getContractInstanceInitializationHash(foreignAddress: ForeignCallSingle) {
-    const address = addressFromSingle(foreignAddress);
-
-    const instance = await this.handlerAsUtility().getContractInstance(address);
-
-    return toForeignCallResult([
-      toSingle(instance.initializationHash),
-      // AVM requires an extra boolean indicating the instance was found
-      toSingle(new Fr(1)),
-    ]);
+  aztec_avm_storageRead(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_storageRead',
+      inputs,
+      handler: ([slot, contractAddress]) => this.handlerAsAvm().storageRead(slot, contractAddress),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_sender() {
-    const sender = await this.handlerAsAvm().sender();
-
-    return toForeignCallResult([toSingle(sender)]);
+  aztec_avm_storageWrite(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_storageWrite',
+      inputs,
+      handler: ([slot, value]) => this.handlerAsAvm().storageWrite(slot, value),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_emitNullifier(foreignNullifier: ForeignCallSingle) {
-    const nullifier = fromSingle(foreignNullifier);
-
-    await this.handlerAsAvm().emitNullifier(nullifier);
-
-    return toForeignCallResult([]);
+  aztec_avm_getContractInstanceDeployer(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_getContractInstanceDeployer',
+      inputs,
+      handler: ([address]) => this.handlerAsAvm().getContractInstanceDeployer(address),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_emitNoteHash(foreignNoteHash: ForeignCallSingle) {
-    const noteHash = fromSingle(foreignNoteHash);
-
-    await this.handlerAsAvm().emitNoteHash(noteHash);
-
-    return toForeignCallResult([]);
+  aztec_avm_getContractInstanceClassId(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_getContractInstanceClassId',
+      inputs,
+      handler: ([address]) => this.handlerAsAvm().getContractInstanceClassId(address),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_nullifierExists(foreignSiloedNullifier: ForeignCallSingle) {
-    const siloedNullifier = fromSingle(foreignSiloedNullifier);
-
-    const exists = await this.handlerAsAvm().nullifierExists(siloedNullifier);
-
-    return toForeignCallResult([toSingle(new Fr(exists))]);
+  aztec_avm_getContractInstanceInitializationHash(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_getContractInstanceInitializationHash',
+      inputs,
+      handler: ([address]) => this.handlerAsAvm().getContractInstanceInitializationHash(address),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_address() {
-    const contractAddress = await this.handlerAsAvm().address();
-
-    return toForeignCallResult([toSingle(contractAddress.toField())]);
+  aztec_avm_getContractInstanceImmutablesHash(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_getContractInstanceImmutablesHash',
+      inputs,
+      handler: ([address]) => this.handlerAsAvm().getContractInstanceImmutablesHash(address),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_blockNumber() {
-    const blockNumber = await this.handlerAsAvm().blockNumber();
-
-    return toForeignCallResult([toSingle(new Fr(blockNumber))]);
+  aztec_avm_sender() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_sender',
+      inputs: [],
+      handler: () => this.handlerAsAvm().sender(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_timestamp() {
-    const timestamp = await this.handlerAsAvm().timestamp();
-
-    return toForeignCallResult([toSingle(new Fr(timestamp))]);
+  aztec_avm_emitNullifier(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_emitNullifier',
+      inputs,
+      handler: ([nullifier]) => this.handlerAsAvm().emitNullifier(nullifier),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_isStaticCall() {
-    const isStaticCall = await this.handlerAsAvm().isStaticCall();
-
-    return toForeignCallResult([toSingle(new Fr(isStaticCall ? 1 : 0))]);
+  aztec_avm_emitNoteHash(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_emitNoteHash',
+      inputs,
+      handler: ([noteHash]) => this.handlerAsAvm().emitNoteHash(noteHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_chainId() {
-    const chainId = await this.handlerAsAvm().chainId();
-
-    return toForeignCallResult([toSingle(chainId)]);
+  aztec_avm_nullifierExists(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_nullifierExists',
+      inputs,
+      handler: ([siloedNullifier]) => this.handlerAsAvm().nullifierExists(siloedNullifier),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_avm_version() {
-    const version = await this.handlerAsAvm().version();
-
-    return toForeignCallResult([toSingle(version)]);
+  aztec_avm_address() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_address',
+      inputs: [],
+      handler: () => this.handlerAsAvm().address(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_returndataSize() {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+  aztec_avm_blockNumber() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_blockNumber',
+      inputs: [],
+      handler: () => this.handlerAsAvm().blockNumber(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_returndataCopy(_foreignRdOffset: ForeignCallSingle, _foreignCopySize: ForeignCallSingle) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+  aztec_avm_timestamp() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_timestamp',
+      inputs: [],
+      handler: () => this.handlerAsAvm().timestamp(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_call(
-    _foreignL2Gas: ForeignCallSingle,
-    _foreignDaGas: ForeignCallSingle,
-    _foreignAddress: ForeignCallSingle,
-    _foreignLength: ForeignCallSingle,
-    _foreignArgs: ForeignCallArray,
-  ) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+  aztec_avm_isStaticCall() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_isStaticCall',
+      inputs: [],
+      handler: () => this.handlerAsAvm().isStaticCall(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_staticCall(
-    _foreignL2Gas: ForeignCallSingle,
-    _foreignDaGas: ForeignCallSingle,
-    _foreignAddress: ForeignCallSingle,
-    _foreignLength: ForeignCallSingle,
-    _foreignArgs: ForeignCallArray,
-  ) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+  aztec_avm_chainId() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_chainId',
+      inputs: [],
+      handler: () => this.handlerAsAvm().chainId(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_successCopy() {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
-  }
-
-  // eslint-disable-next-line camelcase
-  async aztec_txe_privateCallNewFlow(
-    foreignFrom: ForeignCallSingle,
-    foreignTargetContractAddress: ForeignCallSingle,
-    foreignFunctionSelector: ForeignCallSingle,
-    foreignArgs: ForeignCallArray,
-    foreignArgsHash: ForeignCallSingle,
-    foreignIsStaticCall: ForeignCallSingle,
-  ) {
-    const from = addressFromSingle(foreignFrom);
-    const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
-    const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
-    const args = fromArray(foreignArgs);
-    const argsHash = fromSingle(foreignArgsHash);
-    const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-
-    const returnValues = await this.handlerAsTxe().privateCallNewFlow(
-      from,
-      targetContractAddress,
-      functionSelector,
-      args,
-      argsHash,
-      isStaticCall,
-      this.stateHandler.getCurrentJob(),
-    );
-
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
-    return toForeignCallResult([toArray(returnValues)]);
-  }
-
-  // eslint-disable-next-line camelcase
-  async aztec_txe_executeUtilityFunction(
-    foreignTargetContractAddress: ForeignCallSingle,
-    foreignFunctionSelector: ForeignCallSingle,
-    foreignArgs: ForeignCallArray,
-  ) {
-    const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
-    const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
-    const args = fromArray(foreignArgs);
-
-    const returnValues = await this.handlerAsTxe().executeUtilityFunction(
-      targetContractAddress,
-      functionSelector,
-      args,
-      this.stateHandler.getCurrentJob(),
-    );
-
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
-    return toForeignCallResult([toArray(returnValues)]);
-  }
-
-  // eslint-disable-next-line camelcase
-  async aztec_txe_publicCallNewFlow(
-    foreignFrom: ForeignCallSingle,
-    foreignAddress: ForeignCallSingle,
-    foreignCalldata: ForeignCallArray,
-    foreignIsStaticCall: ForeignCallSingle,
-  ) {
-    const from = addressFromSingle(foreignFrom);
-    const address = addressFromSingle(foreignAddress);
-    const calldata = fromArray(foreignCalldata);
-    const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-
-    const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall);
-
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
-    return toForeignCallResult([toArray(returnValues)]);
-  }
-
-  // eslint-disable-next-line camelcase
-  async aztec_prv_getSenderForTags() {
-    const sender = await this.handlerAsPrivate().getSenderForTags();
-
-    // Return a Noir Option struct with `some` and `value` fields
-    if (sender === undefined) {
-      // No sender found, return Option with some=0 and value=0
-      return toForeignCallResult([toSingle(0), toSingle(0)]);
-    } else {
-      // Sender found, return Option with some=1 and value=sender address
-      return toForeignCallResult([toSingle(1), toSingle(sender)]);
-    }
+  aztec_avm_version() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_version',
+      inputs: [],
+      handler: () => this.handlerAsAvm().version(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_setSenderForTags(foreignSenderForTags: ForeignCallSingle) {
-    const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
-
-    await this.handlerAsPrivate().setSenderForTags(senderForTags);
+  aztec_avm_returndataSize() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_returndataSize',
+      inputs: [],
+      handler: () => this.handlerAsAvm().returndataSize(),
+    });
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  aztec_avm_returndataCopy(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_returndataCopy',
+      inputs,
+      handler: ([rdOffset, copySize]) => this.handlerAsAvm().returndataCopy(rdOffset, copySize),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_getNextAppTagAsSender(foreignSender: ForeignCallSingle, foreignRecipient: ForeignCallSingle) {
-    const sender = AztecAddress.fromField(fromSingle(foreignSender));
-    const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
+  aztec_avm_call(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_call',
+      inputs,
+      handler: ([l2Gas, daGas, address, argsLength, args]) =>
+        this.handlerAsAvm().call(l2Gas, daGas, address, argsLength, args),
+    });
+  }
 
-    const nextAppTag = await this.handlerAsPrivate().getNextAppTagAsSender(sender, recipient);
+  // eslint-disable-next-line camelcase
+  aztec_avm_staticCall(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_avm_staticCall',
+      inputs,
+      handler: ([l2Gas, daGas, address, argsLength, args]) =>
+        this.handlerAsAvm().staticCall(l2Gas, daGas, address, argsLength, args),
+    });
+  }
 
-    return toForeignCallResult([toSingle(nextAppTag.value)]);
+  // eslint-disable-next-line camelcase
+  aztec_avm_successCopy() {
+    return callTxeHandler({
+      oracle: 'aztec_avm_successCopy',
+      inputs: [],
+      handler: () => this.handlerAsAvm().successCopy(),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_txe_privateCallNewFlow(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_privateCallNewFlow',
+      inputs,
+      handler: ([
+        from,
+        targetContractAddress,
+        functionSelector,
+        args,
+        argsHash,
+        isStaticCall,
+        additionalScopes,
+        authorizedUtilityCallTargets,
+        gasSettings,
+      ]) =>
+        this.stateHandler.executePrivateCall(
+          from,
+          targetContractAddress,
+          functionSelector,
+          args,
+          argsHash,
+          isStaticCall,
+          additionalScopes,
+          authorizedUtilityCallTargets,
+          gasSettings,
+        ),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_txe_executeUtilityFunction(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_executeUtilityFunction',
+      inputs,
+      handler: ([from, targetContractAddress, functionSelector, args, authorizedUtilityCallTargets]) =>
+        this.stateHandler.executeUtilityFunction(
+          from,
+          targetContractAddress,
+          functionSelector,
+          args,
+          authorizedUtilityCallTargets,
+        ),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_txe_publicCallNewFlow(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_publicCallNewFlow',
+      inputs,
+      handler: ([from, address, calldata, isStaticCall, gasSettings]) =>
+        this.stateHandler.executePublicCall(from, address, calldata, isStaticCall, gasSettings),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_prv_getSenderForTags() {
+    return callTxeHandler({
+      oracle: 'aztec_prv_getSenderForTags',
+      inputs: [],
+      handler: () => this.handlerAsPrivate().getSenderForTags(),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_prv_resolveTaggingStrategy(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_resolveTaggingStrategy',
+      inputs,
+      handler: ([sender, recipient, deliveryMode]) =>
+        this.handlerAsPrivate().resolveTaggingStrategy(sender, recipient, deliveryMode),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_prv_resolveCustomRequest(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_resolveCustomRequest',
+      inputs,
+      handler: ([kind, payload]) => this.handlerAsPrivate().resolveCustomRequest(kind, payload),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_prv_getAppTaggingSecret(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_getAppTaggingSecret',
+      inputs,
+      handler: ([sender, recipient]) => this.handlerAsPrivate().getAppTaggingSecret(sender, recipient),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_prv_getNextTaggingIndex(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_getNextTaggingIndex',
+      inputs,
+      handler: ([secret, deliveryMode]) => this.handlerAsPrivate().getNextTaggingIndex(secret, deliveryMode),
+    });
   }
 }