@aztec/txe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/rpc_translator.js

@@ -1,15 +1,4 @@
-import { Fr } from '@aztec/aztec.js/fields';
-import { ARCHIVE_HEIGHT, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { MembershipWitness } from '@aztec/foundation/trees';
-import { BoundedVec, Option, packAsHintedNote } from '@aztec/pxe/simulator';
-import { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { GasSettings } from '@aztec/stdlib/gas';
-import { MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY, MAX_OFFCHAIN_EFFECT_LEN } from './constants.js';
-import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, blockHashFromSingle, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } from './utils/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 { callTxeHandler } from './oracle/txe_oracle_registry.js';
 export class UnavailableOracleError extends Error {
     constructor(oracleName){
         super(`${oracleName} oracles not available with the current handler`);
@@ -63,965 +52,925 @@ export class RPCTranslator {
         return this.oracleHandler;
     }
     // eslint-disable-next-line camelcase
-    aztec_txe_assertCompatibleOracleVersion(foreignMajor, foreignMinor) {
-        const major = fromSingle(foreignMajor).toNumber();
-        const minor = fromSingle(foreignMinor).toNumber();
-        this.stateHandler.setTxeOracleVersion(major, minor);
-        return toForeignCallResult([]);
+    aztec_txe_assertCompatibleOracleVersion(...inputs) {
+        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, foreignContractAddressValue, foreignAnchorBlockNumberIsSome, foreignAnchorBlockNumberValue, foreignGasSettings) {
-        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
-        const anchorBlockNumber = fromSingle(foreignAnchorBlockNumberIsSome).toBool() ? BlockNumber(fromSingle(foreignAnchorBlockNumberValue).toNumber()) : undefined;
-        const gasSettings = GasSettings.fromFields(fromArray(foreignGasSettings));
-        const privateContextInputs = await this.stateHandler.enterPrivateState(contractAddress, anchorBlockNumber, gasSettings);
-        return toForeignCallResult(privateContextInputs.toFields().map(toSingle));
+    aztec_txe_setPrivateTXEContext(...inputs) {
+        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, foreignContractAddressValue) {
-        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
-        await this.stateHandler.enterPublicState(contractAddress);
-        return toForeignCallResult([]);
+    aztec_txe_setPublicTXEContext(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_setPublicTXEContext',
+            inputs,
+            handler: ([contractAddress])=>this.stateHandler.enterPublicState(contractAddress)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_setUtilityTXEContext(foreignContractAddressIsSome, foreignContractAddressValue) {
-        const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
-        await this.stateHandler.enterUtilityState(contractAddress);
-        return toForeignCallResult([]);
+    aztec_txe_setUtilityTXEContext(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_setUtilityTXEContext',
+            inputs,
+            handler: ([contractAddress])=>this.stateHandler.enterUtilityState(contractAddress)
+        });
     }
     // Other oracles - these get handled by the oracle handler
     // TXE-specific oracles
     // 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
+    aztec_txe_getNextBlockNumber() {
+        return callTxeHandler({
+            oracle: 'aztec_txe_getNextBlockNumber',
+            inputs: [],
+            handler: ()=>this.handlerAsTxe().getNextBlockNumber()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_getNextBlockTimestamp() {
+        return callTxeHandler({
+            oracle: 'aztec_txe_getNextBlockTimestamp',
+            inputs: [],
+            handler: ()=>this.handlerAsTxe().getNextBlockTimestamp()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_advanceBlocksBy(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_advanceBlocksBy',
+            inputs,
+            handler: ([blocks])=>this.handlerAsTxe().advanceBlocksBy(blocks)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_getNextBlockNumber() {
-        const nextBlockNumber = await this.handlerAsTxe().getNextBlockNumber();
-        return toForeignCallResult([
-            toSingle(nextBlockNumber)
-        ]);
+    aztec_txe_advanceTimestampBy(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_advanceTimestampBy',
+            inputs,
+            handler: ([duration])=>this.handlerAsTxe().advanceTimestampBy(duration)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_getNextBlockTimestamp() {
-        const nextBlockTimestamp = await this.handlerAsTxe().getNextBlockTimestamp();
-        return toForeignCallResult([
-            toSingle(nextBlockTimestamp)
-        ]);
+    aztec_txe_deploy(...inputs) {
+        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_advanceBlocksBy(foreignBlocks) {
-        const blocks = fromSingle(foreignBlocks).toNumber();
-        await this.handlerAsTxe().advanceBlocksBy(blocks);
-        return toForeignCallResult([]);
+    aztec_txe_createAccount(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_createAccount',
+            inputs,
+            handler: ([secret, partialAddress])=>this.handlerAsTxe().createAccount(secret, partialAddress)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_txe_advanceTimestampBy(foreignDuration) {
-        const duration = fromSingle(foreignDuration).toBigInt();
-        this.handlerAsTxe().advanceTimestampBy(duration);
-        return toForeignCallResult([]);
+    aztec_txe_addAccount(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_addAccount',
+            inputs,
+            handler: ([secret])=>this.handlerAsTxe().addAccount(secret)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_deploy(artifact, instance, foreignSecret) {
-        const secret = fromSingle(foreignSecret);
-        await this.handlerAsTxe().deploy(artifact, instance, secret);
-        return toForeignCallResult([
-            toArray([
-                instance.salt,
-                instance.deployer.toField(),
-                instance.currentContractClassId,
-                instance.initializationHash,
-                instance.immutablesHash,
-                ...instance.publicKeys.toFields()
-            ])
-        ]);
+    aztec_txe_addAuthWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_addAuthWitness',
+            inputs,
+            handler: ([address, messageHash])=>this.handlerAsTxe().addAuthWitness(address, messageHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_createAccount(foreignSecret) {
-        const secret = fromSingle(foreignSecret);
-        const completeAddress = await this.handlerAsTxe().createAccount(secret);
-        return toForeignCallResult([
-            toSingle(completeAddress.address),
-            ...completeAddress.publicKeys.toFields().map(toSingle)
-        ]);
+    aztec_txe_sendL1ToL2Message(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_sendL1ToL2Message',
+            inputs,
+            handler: ([content, secretHash, sender, recipient])=>this.handlerAsTxe().sendL1ToL2Message(content, secretHash, sender, recipient)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_addAccount(artifact, instance, foreignSecret) {
-        const secret = fromSingle(foreignSecret);
-        const completeAddress = await this.handlerAsTxe().addAccount(artifact, instance, secret);
-        return toForeignCallResult([
-            toSingle(completeAddress.address),
-            ...completeAddress.publicKeys.toFields().map(toSingle)
-        ]);
+    aztec_txe_setTaggingSecretStrategies(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_setTaggingSecretStrategies',
+            inputs,
+            handler: ([unconstrainedStrategy, constrainedStrategy])=>this.handlerAsTxe().setTaggingSecretStrategies(unconstrainedStrategy, constrainedStrategy)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_addAuthWitness(foreignAddress, foreignMessageHash) {
-        const address = addressFromSingle(foreignAddress);
-        const messageHash = fromSingle(foreignMessageHash);
-        await this.handlerAsTxe().addAuthWitness(address, messageHash);
-        return toForeignCallResult([]);
+    aztec_txe_setAuthorizeAllUtilityCallTargets(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_setAuthorizeAllUtilityCallTargets',
+            inputs,
+            handler: ([authorizeAll])=>this.handlerAsTxe().setAuthorizeAllUtilityCallTargets(authorizeAll)
+        });
     }
     // PXE oracles
     // eslint-disable-next-line camelcase
-    aztec_utl_assertCompatibleOracleVersion(foreignMajor, foreignMinor) {
-        const major = fromSingle(foreignMajor).toNumber();
-        const minor = fromSingle(foreignMinor).toNumber();
-        this.handlerAsMisc().assertCompatibleOracleVersion(major, minor);
-        return toForeignCallResult([]);
-    }
-    // eslint-disable-next-line camelcase
-    aztec_utl_getRandomField() {
-        const randomField = this.handlerAsMisc().getRandomField();
-        return toForeignCallResult([
-            toSingle(randomField)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_txe_getLastBlockTimestamp() {
-        const timestamp = await this.handlerAsTxe().getLastBlockTimestamp();
-        return toForeignCallResult([
-            toSingle(new Fr(timestamp))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_txe_getLastTxEffects() {
-        const { txHash, noteHashes, nullifiers, privateLogs } = await this.handlerAsTxe().getLastTxEffects();
-        // Same workaround as `aztec_txe_getPrivateEvents`: Noir cannot yet return nested structs with arrays, so we return
-        // a flat multidimensional array plus per-log lengths and the total count, and reassemble into a
-        // `BoundedVec<BoundedVec<T>>` on the Noir side. Each log contributes only its emitted fields. The rest
-        // is zero-padded to `PRIVATE_LOG_SIZE_IN_FIELDS`.
-        const emittedLogs = privateLogs.map((log)=>log.getEmittedFields());
-        const rawLogStorage = emittedLogs.map((fields)=>fields.concat(Array(PRIVATE_LOG_SIZE_IN_FIELDS - fields.length).fill(new Fr(0)))).concat(Array(MAX_PRIVATE_LOGS_PER_TX - emittedLogs.length).fill(Array(PRIVATE_LOG_SIZE_IN_FIELDS).fill(new Fr(0)))).flat();
-        const logLengths = emittedLogs.map((fields)=>new Fr(fields.length)).concat(Array(MAX_PRIVATE_LOGS_PER_TX - emittedLogs.length).fill(new Fr(0)));
-        const logCount = new Fr(emittedLogs.length);
-        return toForeignCallResult([
-            toSingle(txHash.hash),
-            ...arrayToBoundedVec(toArray(noteHashes), MAX_NOTE_HASHES_PER_TX),
-            ...arrayToBoundedVec(toArray(nullifiers), MAX_NULLIFIERS_PER_TX),
-            toArray(rawLogStorage),
-            toArray(logLengths),
-            toSingle(logCount)
-        ]);
+    aztec_misc_assertCompatibleOracleVersion(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_misc_assertCompatibleOracleVersion',
+            inputs,
+            handler: ([major, minor])=>this.handlerAsMisc().assertCompatibleOracleVersion(major, minor)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_misc_getRandomField() {
+        return callTxeHandler({
+            oracle: 'aztec_misc_getRandomField',
+            inputs: [],
+            handler: ()=>this.handlerAsMisc().getRandomField()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_getLastBlockTimestamp() {
+        return callTxeHandler({
+            oracle: 'aztec_txe_getLastBlockTimestamp',
+            inputs: [],
+            handler: ()=>this.handlerAsTxe().getLastBlockTimestamp()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_getLastTxEffects() {
+        return callTxeHandler({
+            oracle: 'aztec_txe_getLastTxEffects',
+            inputs: [],
+            handler: ()=>this.handlerAsTxe().getLastTxEffects()
+        });
     }
     // eslint-disable-next-line camelcase
     aztec_txe_getLastCallOffchainEffects() {
-        const { effects } = this.stateHandler.getLastCallOffchainEffects();
-        const rawArrayStorage = effects.map((e)=>e.concat(Array(MAX_OFFCHAIN_EFFECT_LEN - e.length).fill(new Fr(0)))).concat(Array(MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY - effects.length).fill(Array(MAX_OFFCHAIN_EFFECT_LEN).fill(new Fr(0)))).flat();
-        const effectLengths = effects.map((e)=>new Fr(e.length)).concat(Array(MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY - effects.length).fill(new Fr(0)));
-        const count = new Fr(effects.length);
-        return toForeignCallResult([
-            toArray(rawArrayStorage),
-            toArray(effectLengths),
-            toSingle(count)
-        ]);
+        return callTxeHandler({
+            oracle: 'aztec_txe_getLastCallOffchainEffects',
+            inputs: [],
+            handler: ()=>this.stateHandler.getLastCallOffchainEffects()
+        });
     }
     // eslint-disable-next-line camelcase
     aztec_txe_getLastCallContext() {
-        const { txHash, anchorBlockTimestamp } = this.stateHandler.getLastCallContext();
-        const isSome = txHash.isZero() ? 0 : 1;
-        return toForeignCallResult([
-            toSingle(isSome),
-            toSingle(txHash),
-            toSingle(new Fr(anchorBlockTimestamp))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_txe_getPrivateEvents(foreignSelector, foreignContractAddress, foreignScope) {
-        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)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    aztec_prv_setHashPreimage(foreignValues, foreignHash) {
-        const values = fromArray(foreignValues);
-        const hash = fromSingle(foreignHash);
-        this.handlerAsPrivate().setHashPreimage(values, hash);
-        return toForeignCallResult([]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_prv_getHashPreimage(foreignHash) {
-        const hash = fromSingle(foreignHash);
-        const returns = await this.handlerAsPrivate().getHashPreimage(hash);
-        return toForeignCallResult([
-            toArray(returns)
-        ]);
-    }
-    // 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, foreignMessage, _foreignLength, foreignFields) {
-        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([]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getFromPublicStorage(foreignBlockHash, foreignContractAddress, foreignStartStorageSlot, foreignNumberOfElements) {
-        const blockHash = blockHashFromSingle(foreignBlockHash);
-        const contractAddress = addressFromSingle(foreignContractAddress);
-        const startStorageSlot = fromSingle(foreignStartStorageSlot);
-        const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
-        const values = await this.handlerAsUtility().getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements);
-        return toForeignCallResult([
-            toArray(values)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getPublicDataWitness(foreignBlockHash, foreignLeafSlot) {
-        const blockHash = blockHashFromSingle(foreignBlockHash);
-        const leafSlot = fromSingle(foreignLeafSlot);
-        const witness = await this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot);
-        return toForeignCallResult(witness.toNoirRepresentation());
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getNotes(foreignOwnerIsSome, foreignOwnerValue, foreignStorageSlot, foreignNumSelects, foreignSelectByIndexes, foreignSelectByOffsets, foreignSelectByLengths, foreignSelectValues, foreignSelectComparators, foreignSortByIndexes, foreignSortByOffsets, foreignSortByLengths, foreignSortOrder, foreignLimit, foreignOffset, foreignStatus, foreignMaxNotes, foreignPackedHintedNoteLength) {
-        // Parse Option<AztecAddress>: ownerIsSome is 0 for None, 1 for Some
-        const owner = fromSingle(foreignOwnerIsSome).toBool() ? Option.some(AztecAddress.fromField(fromSingle(foreignOwnerValue))) : Option.none(AztecAddress.ZERO);
-        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 noteVec = await this.handlerAsUtility().getNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, maxNotes, packedHintedNoteLength);
-        const returnDataAsArrayOfArrays = Array.from(noteVec.data).map((noteData)=>packAsHintedNote({
-                contractAddress: noteData.contractAddress,
-                owner: noteData.owner,
-                randomness: noteData.randomness,
-                storageSlot: noteData.storageSlot,
-                noteNonce: noteData.noteNonce,
-                isPending: noteData.isPending,
-                note: noteData.note
-            }));
-        const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map((subArray)=>subArray.map(toSingle));
-        return toForeignCallResult(arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfForeignCallSingleArrays, maxNotes, packedHintedNoteLength));
-    }
-    // eslint-disable-next-line camelcase
-    aztec_prv_notifyCreatedNote(foreignOwner, foreignStorageSlot, foreignRandomness, foreignNoteTypeId, foreignNote, foreignNoteHash, foreignCounter) {
-        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, foreignNoteHash, foreignCounter) {
-        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) {
-        const innerNullifier = fromSingle(foreignInnerNullifier);
-        await this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier);
-        return toForeignCallResult([]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_prv_isNullifierPending(foreignInnerNullifier, foreignContractAddress) {
-        const innerNullifier = fromSingle(foreignInnerNullifier);
-        const contractAddress = addressFromSingle(foreignContractAddress);
-        const isPending = await this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress);
-        return toForeignCallResult([
-            toSingle(new Fr(isPending))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_doesNullifierExist(foreignInnerNullifier) {
-        const innerNullifier = fromSingle(foreignInnerNullifier);
-        const exists = await this.handlerAsUtility().doesNullifierExist(innerNullifier);
-        return toForeignCallResult([
-            toSingle(new Fr(exists))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getContractInstance(foreignAddress) {
-        const address = addressFromSingle(foreignAddress);
-        const instance = await this.handlerAsUtility().getContractInstance(address);
-        return toForeignCallResult([
-            instance.salt,
-            instance.deployer.toField(),
-            instance.currentContractClassId,
-            instance.initializationHash,
-            instance.immutablesHash,
-            ...instance.publicKeys.toFields()
-        ].map(toSingle));
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getPublicKeysAndPartialAddress(foreignAddress) {
-        const address = addressFromSingle(foreignAddress);
-        const result = await this.handlerAsUtility().getPublicKeysAndPartialAddress(address);
-        // 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.isSome()) {
-            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
-            // Wire shape: [npk_m_hash, ivpk_m.x, ivpk_m.y, ovpk_m_hash, tpk_m_hash, mspk_m_hash, fbpk_m_hash, partial_address] = 8 fields.
-            return toForeignCallResult([
-                toSingle(new Fr(0)),
-                toArray(Array(8).fill(new Fr(0)))
-            ]);
-        } else {
-            // The Noir side hand-decodes a `[Field; 8]` here (see aztec-nr/aztec/src/oracle/keys.nr), so we
-            // emit the 7-field PublicKeys shape + partial_address explicitly
-            // rather than going through `publicKeys.toFields()` (which is the struct-flattened 8-field
-            // wire for oracle returns that decode via struct shape).
-            const { publicKeys, partialAddress } = result.value;
-            return toForeignCallResult([
-                toSingle(new Fr(1)),
-                toArray([
-                    publicKeys.npkMHash,
-                    publicKeys.ivpkM.x,
-                    publicKeys.ivpkM.y,
-                    publicKeys.ovpkMHash,
-                    publicKeys.tpkMHash,
-                    publicKeys.mspkMHash,
-                    publicKeys.fbpkMHash,
-                    partialAddress
-                ])
-            ]);
-        }
+        return callTxeHandler({
+            oracle: 'aztec_txe_getLastCallContext',
+            inputs: [],
+            handler: ()=>this.stateHandler.getLastCallContext()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_getPrivateEvents(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_getPrivateEvents',
+            inputs,
+            handler: ([selector, contractAddress, scope])=>this.stateHandler.getPrivateEvents(selector, contractAddress, scope)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_setHashPreimage(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_setHashPreimage',
+            inputs,
+            handler: ([values, hash])=>this.handlerAsPrivate().setHashPreimage(values, hash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_getHashPreimage(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_getHashPreimage',
+            inputs,
+            handler: ([hash])=>this.handlerAsPrivate().getHashPreimage(hash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_misc_log(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_misc_log',
+            inputs,
+            handler: ([level, message, fieldsSize, fields])=>this.handlerAsMisc().log(level, message, fieldsSize, fields)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getFromPublicStorage(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getFromPublicStorage',
+            inputs,
+            handler: ([blockHash, contractAddress, startStorageSlot, numberOfElements])=>this.handlerAsUtility().getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getPublicDataWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getPublicDataWitness',
+            inputs,
+            handler: ([blockHash, leafSlot])=>this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getNotes(...inputs) {
+        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
+    aztec_prv_notifyCreatedNote(...inputs) {
+        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)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_notifyNullifiedNote(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_notifyNullifiedNote',
+            inputs,
+            handler: ([innerNullifier, noteHash, counter])=>this.handlerAsPrivate().notifyNullifiedNote(innerNullifier, noteHash, counter)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_notifyCreatedNullifier(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_notifyCreatedNullifier',
+            inputs,
+            handler: ([innerNullifier])=>this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_isNullifierPending(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_isNullifierPending',
+            inputs,
+            handler: ([innerNullifier, contractAddress])=>this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_doesNullifierExist(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_doesNullifierExist',
+            inputs,
+            handler: ([innerNullifier])=>this.handlerAsUtility().doesNullifierExist(innerNullifier)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getContractInstance(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getContractInstance',
+            inputs,
+            handler: ([address])=>this.handlerAsUtility().getContractInstance(address)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getKeyValidationRequest(foreignPkMHash) {
-        const pkMHash = fromSingle(foreignPkMHash);
-        const keyValidationRequest = await this.handlerAsUtility().getKeyValidationRequest(pkMHash);
-        return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
+    aztec_utl_getPublicKeysAndPartialAddress(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getPublicKeysAndPartialAddress',
+            inputs,
+            handler: ([address])=>this.handlerAsUtility().getPublicKeysAndPartialAddress(address)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getKeyValidationRequest(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getKeyValidationRequest',
+            inputs,
+            handler: ([pkMHash, keyIndex])=>this.handlerAsUtility().getKeyValidationRequest(pkMHash, keyIndex)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_callPrivateFunction(foreignTargetContractAddress, foreignFunctionSelector, foreignArgsHash, foreignSideEffectCounter, foreignIsStaticCall) {
-        const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
-        const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
-        const argsHash = fromSingle(foreignArgsHash);
-        const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
-        const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const { endSideEffectCounter, returnsHash } = await this.handlerAsPrivate().callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall);
-        return toForeignCallResult([
-            [
-                endSideEffectCounter,
-                returnsHash
-            ].map(toSingle)
-        ]);
+    aztec_prv_callPrivateFunction(...inputs) {
+        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
+    aztec_utl_getNullifierMembershipWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getNullifierMembershipWitness',
+            inputs,
+            handler: ([blockHash, nullifier])=>this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
-        const blockHash = blockHashFromSingle(foreignBlockHash);
-        const nullifier = fromSingle(foreignNullifier);
-        const witness = await this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier);
-        return toForeignCallResult(witness.toNoirRepresentation());
+    aztec_utl_getL1ToL2MembershipWitnessV2(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getL1ToL2MembershipWitnessV2',
+            inputs,
+            handler: ([messageHash, nullifier])=>this.handlerAsUtility().getL1ToL2MembershipWitnessV2(messageHash, nullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getAuthWitness(foreignMessageHash) {
-        const messageHash = fromSingle(foreignMessageHash);
-        const authWitness = await this.handlerAsUtility().getAuthWitness(messageHash);
-        return toForeignCallResult([
-            toArray(authWitness)
-        ]);
+    aztec_utl_getAuthWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getAuthWitness',
+            inputs,
+            handler: ([messageHash])=>this.handlerAsUtility().getAuthWitness(messageHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_assertValidPublicCalldata(foreignCalldataHash) {
-        const calldataHash = fromSingle(foreignCalldataHash);
-        await this.handlerAsPrivate().assertValidPublicCalldata(calldataHash);
-        return toForeignCallResult([]);
+    aztec_prv_assertValidPublicCalldata(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_assertValidPublicCalldata',
+            inputs,
+            handler: ([calldataHash])=>this.handlerAsPrivate().assertValidPublicCalldata(calldataHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_notifyRevertiblePhaseStart(foreignMinRevertibleSideEffectCounter) {
-        const minRevertibleSideEffectCounter = fromSingle(foreignMinRevertibleSideEffectCounter).toNumber();
-        await this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter);
-        return toForeignCallResult([]);
+    aztec_prv_notifyRevertiblePhaseStart(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_notifyRevertiblePhaseStart',
+            inputs,
+            handler: ([minRevertibleSideEffectCounter])=>this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_isExecutionInRevertiblePhase(foreignSideEffectCounter) {
-        const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
-        const isRevertible = await this.handlerAsPrivate().isExecutionInRevertiblePhase(sideEffectCounter);
-        return toForeignCallResult([
-            toSingle(new Fr(isRevertible))
-        ]);
+    aztec_prv_isExecutionInRevertiblePhase(...inputs) {
+        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());
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getBlockHeader(foreignBlockNumber) {
-        const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
-        const header = await this.handlerAsUtility().getBlockHeader(blockNumber);
-        return toForeignCallResult(header.toFields().map(toSingle));
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getNoteHashMembershipWitness(foreignAnchorBlockHash, foreignNoteHash) {
-        const blockHash = blockHashFromSingle(foreignAnchorBlockHash);
-        const noteHash = fromSingle(foreignNoteHash);
-        const witness = await this.handlerAsUtility().getNoteHashMembershipWitness(blockHash, noteHash);
-        return toForeignCallResult(witness.toNoirRepresentation());
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getBlockHashMembershipWitness(foreignAnchorBlockHash, foreignBlockHash) {
-        const anchorBlockHash = blockHashFromSingle(foreignAnchorBlockHash);
-        const blockHash = blockHashFromSingle(foreignBlockHash);
-        const witnessOpt = await this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash);
-        const effective = witnessOpt.value ?? MembershipWitness.empty(ARCHIVE_HEIGHT);
-        return toForeignCallResult([
-            toSingle(new Fr(witnessOpt.isSome() ? 1 : 0)),
-            ...effective.toNoirRepresentation()
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getLowNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
-        const blockHash = blockHashFromSingle(foreignBlockHash);
-        const nullifier = fromSingle(foreignNullifier);
-        const witness = await this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier);
-        return toForeignCallResult(witness.toNoirRepresentation());
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getPendingTaggedLogs(foreignScope) {
-        const scope = AztecAddress.fromField(fromSingle(foreignScope));
-        const slot = await this.handlerAsUtility().getPendingTaggedLogs(scope);
-        return toForeignCallResult([
-            toSingle(slot)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot, foreignScope) {
-        const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
-        const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
-        const scope = AztecAddress.fromField(fromSingle(foreignScope));
-        await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, scope);
-        return toForeignCallResult([]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getLogsByTag(foreignRequestArrayBaseSlot) {
-        const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
-        const responseSlot = await this.handlerAsUtility().getLogsByTag(requestArrayBaseSlot);
-        return toForeignCallResult([
-            toSingle(responseSlot)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getMessageContextsByTxHash(foreignRequestArrayBaseSlot) {
-        const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
-        const responseSlot = await this.handlerAsUtility().getMessageContextsByTxHash(requestArrayBaseSlot);
-        return toForeignCallResult([
-            toSingle(responseSlot)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    aztec_utl_setCapsule(foreignContractAddress, foreignSlot, foreignCapsule, foreignScope) {
-        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-        const slot = fromSingle(foreignSlot);
-        const capsule = fromArray(foreignCapsule);
-        const scope = AztecAddress.fromField(fromSingle(foreignScope));
-        this.handlerAsUtility().setCapsule(contractAddress, slot, capsule, scope);
-        return toForeignCallResult([]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_getCapsule(foreignContractAddress, foreignSlot, foreignTSize, foreignScope) {
-        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-        const slot = fromSingle(foreignSlot);
-        const tSize = fromSingle(foreignTSize).toNumber();
-        const scope = AztecAddress.fromField(fromSingle(foreignScope));
-        const opt = await this.handlerAsUtility().getCapsule(contractAddress, slot, tSize, scope);
-        // 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 (opt.isSome()) {
-            // Data was found so we set `some` to 1 and return it along with `value`.
-            return toForeignCallResult([
-                toSingle(new Fr(1)),
-                toArray(Array.from(opt.value))
-            ]);
-        } else {
-            // 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)))
-            ]);
-        }
+        return callTxeHandler({
+            oracle: 'aztec_utl_getUtilityContext',
+            inputs: [],
+            handler: ()=>this.handlerAsUtility().getUtilityContext()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getBlockHeader(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getBlockHeader',
+            inputs,
+            handler: ([blockNumber])=>this.handlerAsUtility().getBlockHeader(blockNumber)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getNoteHashMembershipWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getNoteHashMembershipWitness',
+            inputs,
+            handler: ([blockHash, noteHash])=>this.handlerAsUtility().getNoteHashMembershipWitness(blockHash, noteHash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getBlockHashMembershipWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getBlockHashMembershipWitness',
+            inputs,
+            handler: ([anchorBlockHash, blockHash])=>this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_areBlockHashesInArchive(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_areBlockHashesInArchive',
+            inputs,
+            handler: ([anchorBlockHash, blockHashes])=>this.handlerAsUtility().areBlockHashesInArchive(anchorBlockHash, blockHashes)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getLowNullifierMembershipWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getLowNullifierMembershipWitness',
+            inputs,
+            handler: ([blockHash, nullifier])=>this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getPendingTaggedLogsV2(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getPendingTaggedLogsV2',
+            inputs,
+            handler: ([scope, providedSecrets])=>this.handlerAsUtility().getPendingTaggedLogsV2(scope, providedSecrets)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_validateAndStoreEnqueuedNotesAndEvents(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_validateAndStoreEnqueuedNotesAndEvents',
+            inputs,
+            handler: ([noteValidationRequests, eventValidationRequests, scope])=>this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(noteValidationRequests, eventValidationRequests, scope)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getLogsByTagV2(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getLogsByTagV2',
+            inputs,
+            handler: ([requestArrayBaseSlot])=>this.handlerAsUtility().getLogsByTagV2(requestArrayBaseSlot)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getResolvedTxs(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getResolvedTxs',
+            inputs,
+            handler: ([requestArrayBaseSlot])=>this.handlerAsUtility().getResolvedTxs(requestArrayBaseSlot)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getTxEffects(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getTxEffects',
+            inputs,
+            handler: ([txHashes])=>this.handlerAsUtility().getTxEffects(txHashes)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setCapsule(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_setCapsule',
+            inputs,
+            handler: ([contractAddress, slot, capsule, scope])=>this.handlerAsUtility().setCapsule(contractAddress, slot, capsule, scope)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getCapsule(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getCapsule',
+            inputs,
+            handler: ([contractAddress, slot, tSize, scope])=>this.handlerAsUtility().getCapsule(contractAddress, slot, tSize, scope)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_deleteCapsule(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_deleteCapsule',
+            inputs,
+            handler: ([contractAddress, slot, scope])=>this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_copyCapsule(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_copyCapsule',
+            inputs,
+            handler: ([contractAddress, srcSlot, dstSlot, numEntries, scope])=>this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, scope)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_pushEphemeral(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_pushEphemeral',
+            inputs,
+            handler: ([slot, elements])=>this.handlerAsUtility().pushEphemeral(slot, elements)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_popEphemeral(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_popEphemeral',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().popEphemeral(slot)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_deleteCapsule(foreignContractAddress, foreignSlot, foreignScope) {
-        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-        const slot = fromSingle(foreignSlot);
-        const scope = AztecAddress.fromField(fromSingle(foreignScope));
-        this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope);
-        return toForeignCallResult([]);
+    aztec_utl_getEphemeral(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getEphemeral',
+            inputs,
+            handler: ([slot, index])=>this.handlerAsUtility().getEphemeral(slot, index)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setEphemeral(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_setEphemeral',
+            inputs,
+            handler: ([slot, index, elements])=>this.handlerAsUtility().setEphemeral(slot, index, elements)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_copyCapsule(foreignContractAddress, foreignSrcSlot, foreignDstSlot, foreignNumEntries, foreignScope) {
-        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-        const srcSlot = fromSingle(foreignSrcSlot);
-        const dstSlot = fromSingle(foreignDstSlot);
-        const numEntries = fromSingle(foreignNumEntries).toNumber();
-        const scope = AztecAddress.fromField(fromSingle(foreignScope));
-        await this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, scope);
-        return toForeignCallResult([]);
+    aztec_utl_getEphemeralLen(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getEphemeralLen',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().getEphemeralLen(slot)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_removeEphemeral(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_removeEphemeral',
+            inputs,
+            handler: ([slot, index])=>this.handlerAsUtility().removeEphemeral(slot, index)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_pushEphemeral(foreignSlot, foreignElements) {
-        const slot = fromSingle(foreignSlot);
-        const elements = fromArray(foreignElements);
-        const newLen = this.handlerAsUtility().pushEphemeral(slot, elements);
-        return toForeignCallResult([
-            toSingle(new Fr(newLen))
-        ]);
+    aztec_utl_clearEphemeral(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_clearEphemeral',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().clearEphemeral(slot)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_popEphemeral(foreignSlot) {
-        const slot = fromSingle(foreignSlot);
-        const element = this.handlerAsUtility().popEphemeral(slot);
-        return toForeignCallResult([
-            toArray(element)
-        ]);
+    aztec_utl_pushTransient(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_pushTransient',
+            inputs,
+            handler: ([slot, elements])=>this.handlerAsUtility().pushTransient(slot, elements)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_getEphemeral(foreignSlot, foreignIndex) {
-        const slot = fromSingle(foreignSlot);
-        const index = fromSingle(foreignIndex).toNumber();
-        const element = this.handlerAsUtility().getEphemeral(slot, index);
-        return toForeignCallResult([
-            toArray(element)
-        ]);
+    aztec_utl_popTransient(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_popTransient',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().popTransient(slot)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_setEphemeral(foreignSlot, foreignIndex, foreignElements) {
-        const slot = fromSingle(foreignSlot);
-        const index = fromSingle(foreignIndex).toNumber();
-        const elements = fromArray(foreignElements);
-        this.handlerAsUtility().setEphemeral(slot, index, elements);
-        return toForeignCallResult([]);
+    aztec_utl_getTransient(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getTransient',
+            inputs,
+            handler: ([slot, index])=>this.handlerAsUtility().getTransient(slot, index)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_getEphemeralLen(foreignSlot) {
-        const slot = fromSingle(foreignSlot);
-        const len = this.handlerAsUtility().getEphemeralLen(slot);
-        return toForeignCallResult([
-            toSingle(new Fr(len))
-        ]);
+    aztec_utl_setTransient(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_setTransient',
+            inputs,
+            handler: ([slot, index, elements])=>this.handlerAsUtility().setTransient(slot, index, elements)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_removeEphemeral(foreignSlot, foreignIndex) {
-        const slot = fromSingle(foreignSlot);
-        const index = fromSingle(foreignIndex).toNumber();
-        this.handlerAsUtility().removeEphemeral(slot, index);
-        return toForeignCallResult([]);
+    aztec_utl_getTransientLen(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getTransientLen',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().getTransientLen(slot)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_clearEphemeral(foreignSlot) {
-        const slot = fromSingle(foreignSlot);
-        this.handlerAsUtility().clearEphemeral(slot);
-        return toForeignCallResult([]);
+    aztec_utl_removeTransient(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_removeTransient',
+            inputs,
+            handler: ([slot, index])=>this.handlerAsUtility().removeTransient(slot, index)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_clearTransient(...inputs) {
+        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.
     // The compiler didn't throw an error, so it took me a while to learn of the existence of this file, and that I need
     // to implement this function here. Isn't there a way to programmatically identify that this is missing, given the
     // existence of a txe_oracle method?
     // eslint-disable-next-line camelcase
-    async aztec_utl_decryptAes128(foreignCiphertextBVecStorage, foreignCiphertextLength, foreignIv, foreignSymKey) {
-        const capacity = foreignCiphertextBVecStorage.length;
-        const ciphertextBuf = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
-        const ciphertext = BoundedVec.from({
-            data: [
-                ...ciphertextBuf
-            ],
-            maxLength: capacity
-        });
-        const iv = fromUintArray(foreignIv, 8);
-        const symKey = fromUintArray(foreignSymKey, 8);
-        // Noir Option<BoundedVec> is encoded as [is_some: Field, storage: Field[], length: Field].
-        const plaintextOpt = await this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey);
-        if (plaintextOpt.isSome()) {
-            const [storage, length] = arrayToBoundedVec(bufferToU8Array(Buffer.from(plaintextOpt.value.data)), capacity);
-            return toForeignCallResult([
-                toSingle(new Fr(1)),
-                storage,
-                length
-            ]);
-        } else {
-            const zeroStorage = toArray(Array(capacity).fill(new Fr(0)));
-            return toForeignCallResult([
-                toSingle(new Fr(0)),
-                zeroStorage,
-                toSingle(new Fr(0))
-            ]);
-        }
+    aztec_utl_decryptAes128(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_decryptAes128',
+            inputs,
+            handler: ([ciphertext, iv, symKey])=>this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getSharedSecrets(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getSharedSecrets',
+            inputs,
+            handler: ([address, ephPksSlot, contractAddress])=>this.handlerAsUtility().getSharedSecrets(address, ephPksSlot, contractAddress)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setContractSyncCacheInvalid(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_setContractSyncCacheInvalid',
+            inputs,
+            handler: ([contractAddress, scopes])=>this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getSharedSecrets(foreignAddress, foreignEphPksSlot, foreignContractAddress) {
-        const address = AztecAddress.fromField(fromSingle(foreignAddress));
-        const ephPksSlot = fromSingle(foreignEphPksSlot);
-        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-        const responseSlot = await this.handlerAsUtility().getSharedSecrets(address, ephPksSlot, contractAddress);
-        return toForeignCallResult([
-            toSingle(responseSlot)
-        ]);
+    aztec_utl_emitOffchainEffect(...inputs) {
+        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);
+            }
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_setContractSyncCacheInvalid(foreignContractAddress, foreignScopes, foreignScopeCount) {
-        const contractAddress = addressFromSingle(foreignContractAddress);
-        const allFields = fromArray(foreignScopes);
-        const count = fromSingle(foreignScopeCount).toNumber();
-        const scopes = BoundedVec.from({
-            data: allFields.slice(0, count).map((f)=>new AztecAddress(f)),
-            maxLength: allFields.length
+    aztec_utl_recordFact(...inputs) {
+        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)
         });
-        this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes);
-        return Promise.resolve(toForeignCallResult([]));
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_emitOffchainEffect(foreignData) {
-        // 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(fromArray(foreignData));
-        return Promise.resolve(toForeignCallResult([]));
+    aztec_utl_deleteFactCollection(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_deleteFactCollection',
+            inputs,
+            handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId])=>this.handlerAsUtility().deleteFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getFactCollection(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getFactCollection',
+            inputs,
+            handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId])=>this.handlerAsUtility().getFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getFactCollectionsByType(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getFactCollectionsByType',
+            inputs,
+            handler: ([contractAddress, scope, factCollectionTypeId])=>this.handlerAsUtility().getFactCollectionsByType(contractAddress, scope, factCollectionTypeId)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_callUtilityFunction(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_callUtilityFunction',
+            inputs,
+            handler: ([contractAddress, functionSelector, args])=>this.handlerAsUtility().callUtilityFunction(contractAddress, functionSelector, args)
+        });
     }
     // AVM opcodes
     // eslint-disable-next-line camelcase
-    aztec_avm_emitPublicLog(_foreignMessage) {
-        // TODO(#8811): Implement
-        return toForeignCallResult([]);
+    aztec_avm_emitPublicLog() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_emitPublicLog',
+            inputs: [],
+            // TODO(#8811): Implement
+            handler: ()=>{}
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_storageRead(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_storageRead',
+            inputs,
+            handler: ([slot, contractAddress])=>this.handlerAsAvm().storageRead(slot, contractAddress)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_storageWrite(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_storageWrite',
+            inputs,
+            handler: ([slot, value])=>this.handlerAsAvm().storageWrite(slot, value)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_getContractInstanceDeployer(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_getContractInstanceDeployer',
+            inputs,
+            handler: ([address])=>this.handlerAsAvm().getContractInstanceDeployer(address)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_storageRead(foreignSlot, foreignContractAddress) {
-        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_avm_getContractInstanceClassId(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_getContractInstanceClassId',
+            inputs,
+            handler: ([address])=>this.handlerAsAvm().getContractInstanceClassId(address)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_storageWrite(foreignSlot, foreignValue) {
-        const slot = fromSingle(foreignSlot);
-        const value = fromSingle(foreignValue);
-        await this.handlerAsAvm().storageWrite(slot, value);
-        return toForeignCallResult([]);
+    aztec_avm_getContractInstanceInitializationHash(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_getContractInstanceInitializationHash',
+            inputs,
+            handler: ([address])=>this.handlerAsAvm().getContractInstanceInitializationHash(address)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_getContractInstanceDeployer(foreignAddress) {
-        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_avm_getContractInstanceImmutablesHash(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_getContractInstanceImmutablesHash',
+            inputs,
+            handler: ([address])=>this.handlerAsAvm().getContractInstanceImmutablesHash(address)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_getContractInstanceClassId(foreignAddress) {
-        const address = addressFromSingle(foreignAddress);
-        const instance = await this.handlerAsUtility().getContractInstance(address);
-        return toForeignCallResult([
-            toSingle(instance.currentContractClassId),
-            // AVM requires an extra boolean indicating the instance was found
-            toSingle(new Fr(1))
-        ]);
+    aztec_avm_sender() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_sender',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().sender()
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_getContractInstanceInitializationHash(foreignAddress) {
-        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_emitNullifier(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_emitNullifier',
+            inputs,
+            handler: ([nullifier])=>this.handlerAsAvm().emitNullifier(nullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_getContractInstanceImmutablesHash(foreignAddress) {
-        const address = addressFromSingle(foreignAddress);
-        const instance = await this.handlerAsUtility().getContractInstance(address);
-        return toForeignCallResult([
-            toSingle(instance.immutablesHash),
-            // AVM requires an extra boolean indicating the instance was found
-            toSingle(new Fr(1))
-        ]);
+    aztec_avm_emitNoteHash(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_emitNoteHash',
+            inputs,
+            handler: ([noteHash])=>this.handlerAsAvm().emitNoteHash(noteHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_sender() {
-        const sender = await this.handlerAsAvm().sender();
-        return toForeignCallResult([
-            toSingle(sender)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_emitNullifier(foreignNullifier) {
-        const nullifier = fromSingle(foreignNullifier);
-        await this.handlerAsAvm().emitNullifier(nullifier);
-        return toForeignCallResult([]);
+    aztec_avm_nullifierExists(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_nullifierExists',
+            inputs,
+            handler: ([siloedNullifier])=>this.handlerAsAvm().nullifierExists(siloedNullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_emitNoteHash(foreignNoteHash) {
-        const noteHash = fromSingle(foreignNoteHash);
-        await this.handlerAsAvm().emitNoteHash(noteHash);
-        return toForeignCallResult([]);
+    aztec_avm_address() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_address',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().address()
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_avm_nullifierExists(foreignSiloedNullifier) {
-        const siloedNullifier = fromSingle(foreignSiloedNullifier);
-        const exists = await this.handlerAsAvm().nullifierExists(siloedNullifier);
-        return toForeignCallResult([
-            toSingle(new Fr(exists))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_address() {
-        const contractAddress = await this.handlerAsAvm().address();
-        return toForeignCallResult([
-            toSingle(contractAddress.toField())
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_blockNumber() {
-        const blockNumber = await this.handlerAsAvm().blockNumber();
-        return toForeignCallResult([
-            toSingle(new Fr(blockNumber))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_timestamp() {
-        const timestamp = await this.handlerAsAvm().timestamp();
-        return toForeignCallResult([
-            toSingle(new Fr(timestamp))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_isStaticCall() {
-        const isStaticCall = await this.handlerAsAvm().isStaticCall();
-        return toForeignCallResult([
-            toSingle(new Fr(isStaticCall ? 1 : 0))
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_chainId() {
-        const chainId = await this.handlerAsAvm().chainId();
-        return toForeignCallResult([
-            toSingle(chainId)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_version() {
-        const version = await this.handlerAsAvm().version();
-        return toForeignCallResult([
-            toSingle(version)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_returndataSize() {
-        const result = await this.handlerAsAvm().returndataSize();
-        return toForeignCallResult([
-            toSingle(result)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_returndataCopy(foreignRdOffset, foreignCopySize) {
-        const rdOffset = fromSingle(foreignRdOffset).toNumber();
-        const copySize = fromSingle(foreignCopySize).toNumber();
-        const result = await this.handlerAsAvm().returndataCopy(rdOffset, copySize);
-        return toForeignCallResult([
-            toArray(result)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_call(foreignL2Gas, foreignDaGas, foreignAddress, foreignLength, foreignArgs) {
-        const l2Gas = fromSingle(foreignL2Gas).toNumber();
-        const daGas = fromSingle(foreignDaGas).toNumber();
-        const address = addressFromSingle(foreignAddress);
-        const argsLength = fromSingle(foreignLength).toNumber();
-        const args = fromArray(foreignArgs);
-        const result = await this.handlerAsAvm().call(l2Gas, daGas, address, argsLength, args);
-        return toForeignCallResult([
-            toArray(result)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_staticCall(foreignL2Gas, foreignDaGas, foreignAddress, foreignLength, foreignArgs) {
-        const l2Gas = fromSingle(foreignL2Gas).toNumber();
-        const daGas = fromSingle(foreignDaGas).toNumber();
-        const address = addressFromSingle(foreignAddress);
-        const argsLength = fromSingle(foreignLength).toNumber();
-        const args = fromArray(foreignArgs);
-        const result = await this.handlerAsAvm().staticCall(l2Gas, daGas, address, argsLength, args);
-        return toForeignCallResult([
-            toArray(result)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_avm_successCopy() {
-        const result = await this.handlerAsAvm().successCopy();
-        return toForeignCallResult([
-            toSingle(result)
-        ]);
-    }
-    // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize→delegate→deserialize.
-    // eslint-disable-next-line camelcase
-    async aztec_txe_privateCallNewFlow(foreignFromIsSome, foreignFromValue, foreignTargetContractAddress, foreignFunctionSelector, foreignArgs, foreignArgsHash, foreignIsStaticCall, foreignAdditionalScopes, foreignAuthorizedUtilityCallTargets, foreignGasSettings) {
-        const from = fromSingle(foreignFromIsSome).toBool() ? addressFromSingle(foreignFromValue) : undefined;
-        const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
-        const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
-        const args = fromArray(foreignArgs);
-        const argsHash = fromSingle(foreignArgsHash);
-        const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const additionalScopes = fromArray(foreignAdditionalScopes).map((field)=>AztecAddress.fromField(field));
-        const authorizedUtilityCallTargets = fromArray(foreignAuthorizedUtilityCallTargets).map((field)=>AztecAddress.fromField(field));
-        const gasSettings = GasSettings.fromFields(fromArray(foreignGasSettings));
-        const returnValues = await this.stateHandler.withTopLevelCallTracking(async ()=>{
-            const { returnValues, offchainEffects } = await this.handlerAsTxe().privateCallNewFlow(from, targetContractAddress, functionSelector, args, argsHash, isStaticCall, additionalScopes, this.stateHandler.getCurrentJob(), authorizedUtilityCallTargets, gasSettings);
-            // Private execution collects offchain effects inside PXE's PrivateExecutionOracle rather than
-            // round-tripping them through `aztec_utl_emitOffchainEffect`, so the session buffer is empty
-            // at this point. Drain the effects from the execution tree into the session buffer so the
-            // next `env.offchain_messages()` call in the test sees them.
-            for (const data of offchainEffects){
-                this.stateHandler.recordOffchainEffect(data);
-            }
-            // TODO(F-335): Avoid doing the following call here.
-            await this.stateHandler.cycleJob();
-            if (isStaticCall) {
-                // Static calls revert their checkpoint and mine no block, so there is no tx hash to tag
-                // offchain effects with. Querying `getLastTxEffects()` here would return an unrelated
-                // predecessor tx.
-                return {
-                    result: returnValues
-                };
-            }
-            const { txHash } = await this.handlerAsTxe().getLastTxEffects();
-            return {
-                result: returnValues,
-                txHash: txHash.hash
-            };
-        });
-        return toForeignCallResult([
-            toArray(returnValues)
-        ]);
-    }
-    // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize→delegate→deserialize.
-    // eslint-disable-next-line camelcase
-    async aztec_txe_executeUtilityFunction(foreignTargetContractAddress, foreignFunctionSelector, foreignArgs, foreignAuthorizedUtilityCallTargets) {
-        const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
-        const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
-        const args = fromArray(foreignArgs);
-        const authorizedUtilityCallTargets = fromArray(foreignAuthorizedUtilityCallTargets).map((field)=>AztecAddress.fromField(field));
-        const returnValues = await this.stateHandler.withTopLevelCallTracking(async ()=>{
-            const returnValues = await this.handlerAsTxe().executeUtilityFunction(targetContractAddress, functionSelector, args, this.stateHandler.getCurrentJob(), authorizedUtilityCallTargets);
-            // TODO(F-335): Avoid doing the following call here.
-            await this.stateHandler.cycleJob();
-            return {
-                result: returnValues
-            };
-        });
-        return toForeignCallResult([
-            toArray(returnValues)
-        ]);
-    }
-    // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize→delegate→deserialize.
-    // eslint-disable-next-line camelcase
-    async aztec_txe_publicCallNewFlow(foreignFromIsSome, foreignFromValue, foreignAddress, foreignCalldata, foreignIsStaticCall, foreignGasSettings) {
-        const from = fromSingle(foreignFromIsSome).toBool() ? addressFromSingle(foreignFromValue) : undefined;
-        const address = addressFromSingle(foreignAddress);
-        const calldata = fromArray(foreignCalldata);
-        const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const gasSettings = GasSettings.fromFields(fromArray(foreignGasSettings));
-        const returnValues = await this.stateHandler.withTopLevelCallTracking(async ()=>{
-            const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall, gasSettings);
-            // TODO(F-335): Avoid doing the following call here.
-            await this.stateHandler.cycleJob();
-            if (isStaticCall) {
-                // See equivalent branch in `aztec_txe_privateCallNewFlow`.
-                return {
-                    result: returnValues
-                };
-            }
-            const { txHash } = await this.handlerAsTxe().getLastTxEffects();
-            return {
-                result: returnValues,
-                txHash: txHash.hash
-            };
-        });
-        return toForeignCallResult([
-            toArray(returnValues)
-        ]);
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_prv_getSenderForTags() {
-        const senderOpt = await this.handlerAsPrivate().getSenderForTags();
-        // Return a Noir Option struct with `some` and `value` fields
-        if (senderOpt.isSome()) {
-            // Sender found, return Option with some=1 and value=sender address
-            return toForeignCallResult([
-                toSingle(1),
-                toSingle(senderOpt.value)
-            ]);
-        } else {
-            // No sender found, return Option with some=0 and value=0
-            return toForeignCallResult([
-                toSingle(0),
-                toSingle(0)
-            ]);
-        }
+    aztec_avm_blockNumber() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_blockNumber',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().blockNumber()
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_getNextAppTagAsSender(foreignSender, foreignRecipient) {
-        const sender = AztecAddress.fromField(fromSingle(foreignSender));
-        const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
-        const nextAppTag = await this.handlerAsPrivate().getNextAppTagAsSender(sender, recipient);
-        return toForeignCallResult([
-            toSingle(nextAppTag.value)
-        ]);
+    aztec_avm_timestamp() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_timestamp',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().timestamp()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_isStaticCall() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_isStaticCall',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().isStaticCall()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_chainId() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_chainId',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().chainId()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_version() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_version',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().version()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_returndataSize() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_returndataSize',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().returndataSize()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_returndataCopy(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_returndataCopy',
+            inputs,
+            handler: ([rdOffset, copySize])=>this.handlerAsAvm().returndataCopy(rdOffset, copySize)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_getNextConstrainedTaggingIndex(foreignAppSiloedSecret) {
-        const appSiloedSecret = fromSingle(foreignAppSiloedSecret);
-        const index = await this.handlerAsPrivate().getNextConstrainedTaggingIndex(appSiloedSecret);
-        return toForeignCallResult([
-            toSingle(new Fr(index))
-        ]);
+    aztec_avm_call(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_call',
+            inputs,
+            handler: ([l2Gas, daGas, address, argsLength, args])=>this.handlerAsAvm().call(l2Gas, daGas, address, argsLength, args)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_staticCall(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_staticCall',
+            inputs,
+            handler: ([l2Gas, daGas, address, argsLength, args])=>this.handlerAsAvm().staticCall(l2Gas, daGas, address, argsLength, args)
+        });
+    }
+    // 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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_resolveCustomRequest',
+            inputs,
+            handler: ([kind, payload])=>this.handlerAsPrivate().resolveCustomRequest(kind, payload)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_getAppTaggingSecret(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_getAppTaggingSecret',
+            inputs,
+            handler: ([sender, recipient])=>this.handlerAsPrivate().getAppTaggingSecret(sender, recipient)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_getNextTaggingIndex(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_getNextTaggingIndex',
+            inputs,
+            handler: ([secret, deliveryMode])=>this.handlerAsPrivate().getNextTaggingIndex(secret, deliveryMode)
+        });
     }
 }