@aztec/txe 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/rpc_translator.js

@@ -0,0 +1,882 @@
+import { callTxeHandler } from './oracle/txe_oracle_registry.js';
+export class UnavailableOracleError extends Error {
+    constructor(oracleName){
+        super(`${oracleName} oracles not available with the current handler`);
+    }
+}
+export class RPCTranslator {
+    stateHandler;
+    oracleHandler;
+    /**
+   * Create a new instance of `RPCTranslator` that will translate all TXE RPC calls to and from the foreign
+   * (`ForeignCallSingle`, `ForeignCallResult`, etc.) and native TS types, delegating actual execution of the oracles
+   * to the different handlers.
+   * @param stateHandler The handler that will process TXE session state transitions, such as entering a private or
+   * public context.
+   * @param oracleHandler The handler that will process all other oracle calls that are not directly related to session
+   * state.
+   */ constructor(stateHandler, oracleHandler){
+        this.stateHandler = stateHandler;
+        this.oracleHandler = oracleHandler;
+    }
+    // Note: If you rename the following functions to not start with "handlerAs", you must also update the validation
+    // check in `TXESession.processFunction`.
+    handlerAsMisc() {
+        if (!('isMisc' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Misc');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsUtility() {
+        if (!('isUtility' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Utility');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsPrivate() {
+        if (!('isPrivate' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Private');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsAvm() {
+        if (!('isAvm' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Avm');
+        }
+        return this.oracleHandler;
+    }
+    handlerAsTxe() {
+        if (!('isTxe' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Txe');
+        }
+        return this.oracleHandler;
+    }
+    // eslint-disable-next-line camelcase
+    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
+    aztec_txe_setTopLevelTXEContext() {
+        return callTxeHandler({
+            oracle: 'aztec_txe_setTopLevelTXEContext',
+            inputs: [],
+            handler: ()=>this.stateHandler.enterTopLevelState()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    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
+    aztec_txe_setPublicTXEContext(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_setPublicTXEContext',
+            inputs,
+            handler: ([contractAddress])=>this.stateHandler.enterPublicState(contractAddress)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    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() {
+        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
+    aztec_txe_advanceTimestampBy(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_advanceTimestampBy',
+            inputs,
+            handler: ([duration])=>this.handlerAsTxe().advanceTimestampBy(duration)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    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
+    aztec_txe_createAccount(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_createAccount',
+            inputs,
+            handler: ([secret])=>this.handlerAsTxe().createAccount(secret)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_addAccount(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_addAccount',
+            inputs,
+            handler: ([secret])=>this.handlerAsTxe().addAccount(secret)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_addAuthWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_addAuthWitness',
+            inputs,
+            handler: ([address, messageHash])=>this.handlerAsTxe().addAuthWitness(address, messageHash)
+        });
+    }
+    // PXE oracles
+    // eslint-disable-next-line camelcase
+    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() {
+        return callTxeHandler({
+            oracle: 'aztec_txe_getLastCallOffchainEffects',
+            inputs: [],
+            handler: ()=>this.stateHandler.getLastCallOffchainEffects()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_txe_getLastCallContext() {
+        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: async ([selector, contractAddress, scope])=>{
+                // 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();
+                }
+                return this.handlerAsTxe().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
+    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])=>this.handlerAsUtility().getKeyValidationRequest(pkMHash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    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
+    aztec_utl_getAuthWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getAuthWitness',
+            inputs,
+            handler: ([messageHash])=>this.handlerAsUtility().getAuthWitness(messageHash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_assertValidPublicCalldata(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_assertValidPublicCalldata',
+            inputs,
+            handler: ([calldataHash])=>this.handlerAsPrivate().assertValidPublicCalldata(calldataHash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_notifyRevertiblePhaseStart(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_prv_notifyRevertiblePhaseStart',
+            inputs,
+            handler: ([minRevertibleSideEffectCounter])=>this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    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() {
+        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_getLowNullifierMembershipWitness(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getLowNullifierMembershipWitness',
+            inputs,
+            handler: ([blockHash, nullifier])=>this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getPendingTaggedLogs(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getPendingTaggedLogs',
+            inputs,
+            handler: ([scope, providedSecrets])=>this.handlerAsUtility().getPendingTaggedLogs(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_getLogsByTag(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getLogsByTag',
+            inputs,
+            handler: ([requestArrayBaseSlot])=>this.handlerAsUtility().getLogsByTag(requestArrayBaseSlot)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getMessageContextsByTxHash(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_getMessageContextsByTxHash',
+            inputs,
+            handler: ([requestArrayBaseSlot])=>this.handlerAsUtility().getMessageContextsByTxHash(requestArrayBaseSlot)
+        });
+    }
+    // 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_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
+    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_clearEphemeral(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_utl_clearEphemeral',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().clearEphemeral(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
+    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
+    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);
+            }
+        });
+    }
+    // AVM opcodes
+    // eslint-disable-next-line camelcase
+    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
+    aztec_avm_getContractInstanceClassId(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_getContractInstanceClassId',
+            inputs,
+            handler: ([address])=>this.handlerAsAvm().getContractInstanceClassId(address)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_getContractInstanceInitializationHash(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_getContractInstanceInitializationHash',
+            inputs,
+            handler: ([address])=>this.handlerAsAvm().getContractInstanceInitializationHash(address)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_getContractInstanceImmutablesHash(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_getContractInstanceImmutablesHash',
+            inputs,
+            handler: ([address])=>this.handlerAsAvm().getContractInstanceImmutablesHash(address)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_sender() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_sender',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().sender()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_emitNullifier(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_emitNullifier',
+            inputs,
+            handler: ([nullifier])=>this.handlerAsAvm().emitNullifier(nullifier)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_emitNoteHash(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_emitNoteHash',
+            inputs,
+            handler: ([noteHash])=>this.handlerAsAvm().emitNoteHash(noteHash)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_nullifierExists(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_avm_nullifierExists',
+            inputs,
+            handler: ([siloedNullifier])=>this.handlerAsAvm().nullifierExists(siloedNullifier)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_address() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_address',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().address()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_avm_blockNumber() {
+        return callTxeHandler({
+            oracle: 'aztec_avm_blockNumber',
+            inputs: [],
+            handler: ()=>this.handlerAsAvm().blockNumber()
+        });
+    }
+    // eslint-disable-next-line camelcase
+    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
+    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()
+        });
+    }
+    // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize->delegate->deserialize.
+    // eslint-disable-next-line camelcase
+    aztec_txe_privateCallNewFlow(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_privateCallNewFlow',
+            inputs,
+            handler: async ([from, targetContractAddress, functionSelector, args, argsHash, isStaticCall, additionalScopes, authorizedUtilityCallTargets, gasSettings])=>{
+                const returnValues = await this.stateHandler.withTopLevelCallTracking(async ()=>{
+                    const { returnValues, offchainEffects } = await this.handlerAsTxe().privateCallNewFlow(from?.value, 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 returnValues;
+            }
+        });
+    }
+    // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize->delegate->deserialize.
+    // eslint-disable-next-line camelcase
+    aztec_txe_executeUtilityFunction(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_executeUtilityFunction',
+            inputs,
+            handler: async ([targetContractAddress, functionSelector, args, authorizedUtilityCallTargets])=>{
+                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 returnValues;
+            }
+        });
+    }
+    // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize->delegate->deserialize.
+    // eslint-disable-next-line camelcase
+    aztec_txe_publicCallNewFlow(...inputs) {
+        return callTxeHandler({
+            oracle: 'aztec_txe_publicCallNewFlow',
+            inputs,
+            handler: async ([from, address, calldata, isStaticCall, gasSettings])=>{
+                const returnValues = await this.stateHandler.withTopLevelCallTracking(async ()=>{
+                    const returnValues = await this.handlerAsTxe().publicCallNewFlow(from?.value, 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 returnValues;
+            }
+        });
+    }
+    // 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_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)
+        });
+    }
+}