@aztec/pxe 0.0.1-commit.b6e433891 → 0.0.1-commit.b9865e97

package/dest/contract_function_simulator/oracle/oracle.js

@@ -1,13 +1,5 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { Point } from '@aztec/foundation/curves/grumpkin';
-import { arrayOfArraysToBoundedVecOfArrays, bufferToBoundedVec, fromUintArray, fromUintBoundedVec, toACVMField } from '@aztec/simulator/client';
-import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { BlockHash } from '@aztec/stdlib/block';
-import { ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
-import { buildLegacyOracleCallbacks } from './legacy_oracle_mappings.js';
-import { packAsHintedNote } from './note_packing_utils.js';
+import { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
+import { callHandler } from './oracle_registry.js';
 export class UnavailableOracleError extends Error {
     constructor(oracleName){
         super(`${oracleName} oracles not available with the current handler`);
@@ -15,6 +7,25 @@ export class UnavailableOracleError extends Error {
 }
 /**
  * A data source that has all the apis required by Aztec.nr.
+ *
+ * ## Oracle naming conventions
+ *
+ * We try to keep oracle naming consistent, please see below the conventions we adhere to.
+ *
+ * Each oracle method name has the form `aztec_{scope}_{verb}{Object}`, where:
+ *
+ * - **Scope prefix** indicates the execution context required:
+ *   - `aztec_prv_` — available only during private function execution.
+ *   - `aztec_utl_` — available during both utility and private execution.
+ *
+ * - **Verb** signals the operation's semantics (verb-first, then object):
+ *   - `get`              — read / lookup / get data from oracle into contract.
+ *   - `does`/`is`/`has`  — predicate (returns boolean).
+ *   - `emit`/`notify`    — propagate data from contract to oracle.
+ *   - `set`              — contract driven oracle state mutation (capsules, execution cache, tagging, etc).
+ *   - `call`             — trigger nested execution (control flow).
+ *   - `assert`           — validate a condition, throw on failure.
+ *   - Standalone verbs (`delete`, `copy`, `decrypt`, `log`, etc) are used when no generic verb fits.
  */ export class Oracle {
     handler;
     constructor(handler){
@@ -52,8 +63,8 @@ export class UnavailableOracleError extends Error {
         // Validate oracle names - these must be prefixed with either "aztec_prv_" or "aztec_utl_" to indicate their scope
         // and must correspond to a function on the Oracle class.
         oracleNames.forEach((name)=>{
-            if (!name.startsWith('aztec_prv_') && !name.startsWith('aztec_utl_')) {
-                throw new Error(`Oracle function "${name}" must be prefixed with either "aztec_prv_" or "aztec_utl_" to indicate its scope`);
+            if (!name.startsWith('aztec_prv_') && !name.startsWith('aztec_utl_') && !name.startsWith('aztec_misc_')) {
+                throw new Error(`Oracle function "${name}" must be prefixed with "aztec_prv_", "aztec_utl_", or "aztec_misc_" to indicate its scope`);
             }
             const method = this[name];
             if (typeof method !== 'function') {
@@ -66,372 +77,476 @@ export class UnavailableOracleError extends Error {
             acc[name] = method.bind(this);
             return acc;
         }, {});
-        return {
-            ...callback,
-            ...buildLegacyOracleCallbacks(this)
-        };
+        // Wrap in a Proxy to intercept access to missing oracle names and provide enhanced error messages when the
+        // contract's minor version is higher than the PXE's (i.e. the contract expects oracles that were added in a newer
+        // minor version).
+        const handler = this.handler;
+        return new Proxy(callback, {
+            get (target, prop) {
+                if (prop in target) {
+                    return target[prop];
+                }
+                // Return a function that throws with an enhanced error message if applicable
+                return ()=>{
+                    let contractVersion = undefined;
+                    if ('nonOracleFunctionGetContractOracleVersion' in handler) {
+                        contractVersion = handler.nonOracleFunctionGetContractOracleVersion();
+                    }
+                    if (!contractVersion) {
+                        throw new Error(`Oracle '${prop}' not found and the contract's oracle version is unknown (the version check oracle ` + `was not called before '${prop}'). This usually means the contract was not compiled with the ` + `#[aztec] macro, which injects the version check as the first oracle call in every private/utility ` + `external function. If you're using a custom entry point, ensure assert_compatible_oracle_version() ` + `is called before any other oracle calls. See https://docs.aztec.network/errors/8`);
+                    } else if (contractVersion.minor > ORACLE_VERSION_MINOR) {
+                        throw new Error(`Oracle '${prop}' not found.` + ` This usually means the contract requires a newer private execution environment than you have.` + ` Upgrade your private execution environment to a compatible version. The contract was compiled with` + ` Aztec.nr oracle version ${contractVersion.major}.${contractVersion.minor}, but this private` + ` execution environment only supports up to ${ORACLE_VERSION_MAJOR}.${ORACLE_VERSION_MINOR}.` + ` See https://docs.aztec.network/errors/8`);
+                    } else {
+                        throw new Error(`Oracle '${prop}' not found.` + ` The contract's oracle version (${contractVersion.major}.${contractVersion.minor}) is compatible` + ` with this private execution environment (${ORACLE_VERSION_MAJOR}.${ORACLE_VERSION_MINOR}), so all` + ` standard oracles should be available. This could mean the contract was compiled against a modified` + ` version of Aztec.nr, or that it references an oracle that does not exist.` + ` See https://docs.aztec.network/errors/8`);
+                    }
+                };
+            }
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_assertCompatibleOracleVersion([version]) {
-        this.handlerAsMisc().assertCompatibleOracleVersion(Fr.fromString(version).toNumber());
-        return Promise.resolve([]);
+    aztec_misc_assertCompatibleOracleVersion(...inputs) {
+        return callHandler({
+            oracle: 'aztec_misc_assertCompatibleOracleVersion',
+            inputs,
+            handler: ([major, minor])=>{
+                this.handlerAsMisc().assertCompatibleOracleVersion(major, minor);
+            }
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_getRandomField() {
-        const val = this.handlerAsMisc().getRandomField();
-        return Promise.resolve([
-            toACVMField(val)
-        ]);
+    aztec_misc_getRandomField() {
+        return callHandler({
+            oracle: 'aztec_misc_getRandomField',
+            inputs: [],
+            handler: ()=>this.handlerAsMisc().getRandomField()
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_prv_storeInExecutionCache(values, [hash]) {
-        this.handlerAsPrivate().storeInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
-        return Promise.resolve([]);
+    aztec_prv_setHashPreimage(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_setHashPreimage',
+            inputs,
+            handler: ([values, hash])=>{
+                this.handlerAsPrivate().setHashPreimage(values, hash);
+            }
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_loadFromExecutionCache([returnsHash]) {
-        const values = await this.handlerAsPrivate().loadFromExecutionCache(Fr.fromString(returnsHash));
-        return [
-            values.map(toACVMField)
-        ];
+    aztec_prv_getHashPreimage(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_getHashPreimage',
+            inputs,
+            handler: ([returnsHash])=>this.handlerAsPrivate().getHashPreimage(returnsHash)
+        });
     }
     // eslint-disable-next-line camelcase
     aztec_utl_getUtilityContext() {
-        const context = this.handlerAsUtility().getUtilityContext();
-        return Promise.resolve(context.toNoirRepresentation());
+        return callHandler({
+            oracle: 'aztec_utl_getUtilityContext',
+            inputs: [],
+            handler: ()=>this.handlerAsUtility().getUtilityContext()
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getKeyValidationRequest([pkMHash]) {
-        const keyValidationRequest = await this.handlerAsUtility().getKeyValidationRequest(Fr.fromString(pkMHash));
-        return keyValidationRequest.toFields().map(toACVMField);
+    aztec_utl_getKeyValidationRequest(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getKeyValidationRequest',
+            inputs,
+            handler: ([pkMHash])=>this.handlerAsUtility().getKeyValidationRequest(pkMHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getContractInstance([address]) {
-        const instance = await this.handlerAsUtility().getContractInstance(AztecAddress.fromField(Fr.fromString(address)));
-        return [
-            instance.salt,
-            instance.deployer,
-            instance.currentContractClassId,
-            instance.initializationHash,
-            ...instance.publicKeys.toFields()
-        ].map(toACVMField);
+    aztec_utl_getContractInstance(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getContractInstance',
+            inputs,
+            handler: ([address])=>this.handlerAsUtility().getContractInstance(address)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getNoteHashMembershipWitness([anchorBlockHash], [noteHash]) {
-        const parsedAnchorBlockHash = BlockHash.fromString(anchorBlockHash);
-        const parsedNoteHash = Fr.fromString(noteHash);
-        const witness = await this.handlerAsUtility().getNoteHashMembershipWitness(parsedAnchorBlockHash, parsedNoteHash);
-        if (!witness) {
-            throw new Error(`Note hash ${noteHash} not found in the note hash tree at anchor block hash ${parsedAnchorBlockHash.toString()}.`);
-        }
-        return witness.toNoirRepresentation();
+    aztec_utl_getNoteHashMembershipWitness(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getNoteHashMembershipWitness',
+            inputs,
+            handler: ([anchorBlockHash, noteHash])=>this.handlerAsUtility().getNoteHashMembershipWitness(anchorBlockHash, noteHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getBlockHashMembershipWitness([anchorBlockHash], [blockHash]) {
-        const parsedAnchorBlockHash = BlockHash.fromString(anchorBlockHash);
-        const parsedBlockHash = BlockHash.fromString(blockHash);
-        const witness = await this.handlerAsUtility().getBlockHashMembershipWitness(parsedAnchorBlockHash, parsedBlockHash);
-        if (!witness) {
-            throw new Error(`Block hash ${parsedBlockHash.toString()} not found in the archive tree at anchor block ${parsedAnchorBlockHash.toString()}.`);
-        }
-        return witness.toNoirRepresentation();
+    aztec_utl_getBlockHashMembershipWitness(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getBlockHashMembershipWitness',
+            inputs,
+            handler: ([anchorBlockHash, blockHash])=>this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getNullifierMembershipWitness([blockHash], [nullifier]) {
-        const parsedBlockHash = BlockHash.fromString(blockHash);
-        const parsedNullifier = Fr.fromString(nullifier);
-        const witness = await this.handlerAsUtility().getNullifierMembershipWitness(parsedBlockHash, parsedNullifier);
-        if (!witness) {
-            throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`);
-        }
-        return witness.toNoirRepresentation();
+    aztec_utl_getNullifierMembershipWitness(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getNullifierMembershipWitness',
+            inputs,
+            handler: ([blockHash, nullifier])=>this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getLowNullifierMembershipWitness([blockHash], [nullifier]) {
-        const parsedBlockHash = BlockHash.fromString(blockHash);
-        const parsedNullifier = Fr.fromString(nullifier);
-        const witness = await this.handlerAsUtility().getLowNullifierMembershipWitness(parsedBlockHash, parsedNullifier);
-        if (!witness) {
-            throw new Error(`Low nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`);
-        }
-        return witness.toNoirRepresentation();
+    aztec_utl_getLowNullifierMembershipWitness(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getLowNullifierMembershipWitness',
+            inputs,
+            handler: ([blockHash, nullifier])=>this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getPublicDataWitness([blockHash], [leafSlot]) {
-        const parsedBlockHash = BlockHash.fromString(blockHash);
-        const parsedLeafSlot = Fr.fromString(leafSlot);
-        const witness = await this.handlerAsUtility().getPublicDataWitness(parsedBlockHash, parsedLeafSlot);
-        if (!witness) {
-            throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block hash ${parsedBlockHash.toString()}.`);
-        }
-        return witness.toNoirRepresentation();
+    aztec_utl_getPublicDataWitness(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getPublicDataWitness',
+            inputs,
+            handler: ([blockHash, leafSlot])=>this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getBlockHeader([blockNumber]) {
-        const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
-        const header = await this.handlerAsUtility().getBlockHeader(BlockNumber(parsedBlockNumber));
-        if (!header) {
-            throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
-        }
-        return header.toFields().map(toACVMField);
+    aztec_utl_getBlockHeader(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getBlockHeader',
+            inputs,
+            handler: ([blockNumber])=>this.handlerAsUtility().getBlockHeader(blockNumber)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getAuthWitness([messageHash]) {
-        const messageHashField = Fr.fromString(messageHash);
-        const witness = await this.handlerAsUtility().getAuthWitness(messageHashField);
-        if (!witness) {
-            throw new Error(`Unknown auth witness for message hash ${messageHashField}`);
-        }
-        return [
-            witness.map(toACVMField)
-        ];
+    aztec_utl_getAuthWitness(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getAuthWitness',
+            inputs,
+            handler: ([messageHash])=>this.handlerAsUtility().getAuthWitness(messageHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_tryGetPublicKeysAndPartialAddress([address]) {
-        const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
-        const result = await this.handlerAsUtility().tryGetPublicKeysAndPartialAddress(parsedAddress);
-        // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
-        // with two fields: `some` (a boolean) and `value` (a field array in this case).
-        if (result === undefined) {
-            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
-            return [
-                toACVMField(0),
-                Array(13).fill(toACVMField(0))
-            ];
-        } else {
-            // Data was found so we set `some` to 1 and return it along with `value`.
-            return [
-                toACVMField(1),
-                [
-                    ...result.publicKeys.toFields(),
-                    result.partialAddress
-                ].map(toACVMField)
-            ];
-        }
+    aztec_utl_getPublicKeysAndPartialAddress(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getPublicKeysAndPartialAddress',
+            inputs,
+            handler: ([address])=>this.handlerAsUtility().getPublicKeysAndPartialAddress(address)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getNotes([ownerSome], [ownerValue], [storageSlot], [numSelects], selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, [limit], [offset], [status], [maxNotes], [packedHintedNoteLength]) {
-        // Parse Option<AztecAddress>: ownerSome is 0 for None, 1 for Some
-        const owner = Fr.fromString(ownerSome).toNumber() === 1 ? AztecAddress.fromString(ownerValue) : undefined;
-        const noteDatas = await this.handlerAsUtility().getNotes(owner, Fr.fromString(storageSlot), +numSelects, selectByIndexes.map((s)=>+s), selectByOffsets.map((s)=>+s), selectByLengths.map((s)=>+s), selectValues.map(Fr.fromString), selectComparators.map((s)=>+s), sortByIndexes.map((s)=>+s), sortByOffsets.map((s)=>+s), sortByLengths.map((s)=>+s), sortOrder.map((s)=>+s), +limit, +offset, +status);
-        const returnDataAsArrayOfPackedHintedNotes = noteDatas.map((noteData)=>packAsHintedNote({
-                contractAddress: noteData.contractAddress,
-                owner: noteData.owner,
-                randomness: noteData.randomness,
-                storageSlot: noteData.storageSlot,
-                noteNonce: noteData.noteNonce,
-                isPending: noteData.isPending,
-                note: noteData.note
-            }));
-        // Now we convert each sub-array to an array of ACVMField
-        const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedHintedNotes.map((subArray)=>subArray.map(toACVMField));
-        // At last we convert the array of arrays to a bounded vec of arrays
-        return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedHintedNoteLength);
+    aztec_utl_getNotes(...inputs) {
+        return callHandler({
+            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([owner], [storageSlot], [randomness], [noteTypeId], note, [noteHash], [counter]) {
-        this.handlerAsPrivate().notifyCreatedNote(AztecAddress.fromString(owner), Fr.fromString(storageSlot), Fr.fromString(randomness), NoteSelector.fromField(Fr.fromString(noteTypeId)), note.map(Fr.fromString), Fr.fromString(noteHash), +counter);
-        return Promise.resolve([]);
+    aztec_prv_notifyCreatedNote(...inputs) {
+        return callHandler({
+            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
-    async aztec_prv_notifyNullifiedNote([innerNullifier], [noteHash], [counter]) {
-        await this.handlerAsPrivate().notifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
-        return [];
+    aztec_prv_notifyNullifiedNote(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_notifyNullifiedNote',
+            inputs,
+            handler: ([innerNullifier, noteHash, counter])=>this.handlerAsPrivate().notifyNullifiedNote(innerNullifier, noteHash, counter)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_notifyCreatedNullifier([innerNullifier]) {
-        await this.handlerAsPrivate().notifyCreatedNullifier(Fr.fromString(innerNullifier));
-        return [];
+    aztec_prv_notifyCreatedNullifier(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_notifyCreatedNullifier',
+            inputs,
+            handler: ([innerNullifier])=>this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_isNullifierPending([innerNullifier], [contractAddress]) {
-        const isPending = await this.handlerAsPrivate().isNullifierPending(Fr.fromString(innerNullifier), AztecAddress.fromString(contractAddress));
-        return [
-            toACVMField(isPending)
-        ];
+    aztec_prv_isNullifierPending(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_isNullifierPending',
+            inputs,
+            handler: ([innerNullifier, contractAddress])=>this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_checkNullifierExists([innerNullifier]) {
-        const exists = await this.handlerAsUtility().checkNullifierExists(Fr.fromString(innerNullifier));
-        return [
-            toACVMField(exists)
-        ];
+    aztec_utl_doesNullifierExist(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_doesNullifierExist',
+            inputs,
+            handler: ([innerNullifier])=>this.handlerAsUtility().doesNullifierExist(innerNullifier)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getL1ToL2MembershipWitness([contractAddress], [messageHash], [secret]) {
-        const message = await this.handlerAsUtility().getL1ToL2MembershipWitness(AztecAddress.fromString(contractAddress), Fr.fromString(messageHash), Fr.fromString(secret));
-        return message.toNoirRepresentation();
+    aztec_utl_getL1ToL2MembershipWitness(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getL1ToL2MembershipWitness',
+            inputs,
+            handler: ([contractAddress, messageHash, secret])=>this.handlerAsUtility().getL1ToL2MembershipWitness(contractAddress, messageHash, secret)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_storageRead([blockHash], [contractAddress], [startStorageSlot], [numberOfElements]) {
-        const values = await this.handlerAsUtility().storageRead(BlockHash.fromString(blockHash), new AztecAddress(Fr.fromString(contractAddress)), Fr.fromString(startStorageSlot), +numberOfElements);
-        return [
-            values.map(toACVMField)
-        ];
+    aztec_utl_getFromPublicStorage(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getFromPublicStorage',
+            inputs,
+            handler: ([blockHash, contractAddress, startStorageSlot, numberOfElements])=>this.handlerAsUtility().getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements)
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_prv_notifyCreatedContractClassLog([contractAddress], message, [length], [counter]) {
-        const logFields = new ContractClassLogFields(message.map(Fr.fromString));
-        const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
-        this.handlerAsPrivate().notifyCreatedContractClassLog(log, +counter);
-        return Promise.resolve([]);
+    aztec_utl_callUtilityFunction(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_callUtilityFunction',
+            inputs,
+            handler: ([contractAddress, functionSelector, args])=>this.handlerAsUtility().callUtilityFunction(contractAddress, functionSelector, args)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_log(level, message, _ignoredFieldsSize, fields) {
-        const levelFr = Fr.fromString(level[0]);
-        const messageStr = message.map((acvmField)=>String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
-        const fieldsFr = fields.map(Fr.fromString);
-        await this.handlerAsMisc().log(levelFr.toNumber(), messageStr, fieldsFr);
-        return [];
+    aztec_prv_notifyCreatedContractClassLog(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_notifyCreatedContractClassLog',
+            inputs,
+            handler: ([log, counter])=>{
+                this.handlerAsPrivate().notifyCreatedContractClassLog(log, counter);
+            }
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_misc_log(...inputs) {
+        return callHandler({
+            oracle: 'aztec_misc_log',
+            inputs,
+            handler: ([level, message, fieldsSize, fields])=>this.handlerAsMisc().log(level, message, fieldsSize, fields)
+        });
     }
     // This function's name is directly hardcoded in `circuit_recorder.ts`. Don't forget to update it there if you
     // change the name here.
     // eslint-disable-next-line camelcase
-    async aztec_prv_callPrivateFunction([contractAddress], [functionSelector], [argsHash], [sideEffectCounter], [isStaticCall]) {
-        const { endSideEffectCounter, returnsHash } = await this.handlerAsPrivate().callPrivateFunction(AztecAddress.fromField(Fr.fromString(contractAddress)), FunctionSelector.fromField(Fr.fromString(functionSelector)), Fr.fromString(argsHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
-        return [
-            [
-                endSideEffectCounter,
-                returnsHash
-            ].map(toACVMField)
-        ];
+    aztec_prv_callPrivateFunction(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_callPrivateFunction',
+            inputs,
+            handler: ([contractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall])=>this.handlerAsPrivate().callPrivateFunction(contractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_validatePublicCalldata([calldataHash]) {
-        await this.handlerAsPrivate().validatePublicCalldata(Fr.fromString(calldataHash));
-        return [];
+    aztec_prv_assertValidPublicCalldata(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_assertValidPublicCalldata',
+            inputs,
+            handler: ([calldataHash])=>this.handlerAsPrivate().assertValidPublicCalldata(calldataHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_notifyRevertiblePhaseStart([minRevertibleSideEffectCounter]) {
-        await this.handlerAsPrivate().notifyRevertiblePhaseStart(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
-        return Promise.resolve([]);
+    aztec_prv_notifyRevertiblePhaseStart(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_notifyRevertiblePhaseStart',
+            inputs,
+            handler: ([minRevertibleSideEffectCounter])=>this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_inRevertiblePhase([sideEffectCounter]) {
-        const isRevertible = await this.handlerAsPrivate().inRevertiblePhase(Fr.fromString(sideEffectCounter).toNumber());
-        return Promise.resolve([
-            toACVMField(isRevertible)
-        ]);
+    aztec_prv_isExecutionInRevertiblePhase(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_isExecutionInRevertiblePhase',
+            inputs,
+            handler: ([sideEffectCounter])=>this.handlerAsPrivate().isExecutionInRevertiblePhase(sideEffectCounter)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_getNextAppTagAsSender([sender], [recipient]) {
-        const tag = await this.handlerAsPrivate().getNextAppTagAsSender(AztecAddress.fromString(sender), AztecAddress.fromString(recipient));
-        return [
-            toACVMField(tag.value)
-        ];
+    aztec_prv_getAppTaggingSecret(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_getAppTaggingSecret',
+            inputs,
+            handler: ([sender, recipient])=>this.handlerAsPrivate().getAppTaggingSecret(sender, recipient)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_fetchTaggedLogs([pendingTaggedLogArrayBaseSlot]) {
-        await this.handlerAsUtility().fetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
-        return [];
+    aztec_prv_getNextTaggingIndex(...inputs) {
+        return callHandler({
+            oracle: 'aztec_prv_getNextTaggingIndex',
+            inputs,
+            handler: ([secret, mode])=>this.handlerAsPrivate().getNextTaggingIndex(secret, mode)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_validateAndStoreEnqueuedNotesAndEvents([contractAddress], [noteValidationRequestsArrayBaseSlot], [eventValidationRequestsArrayBaseSlot], [maxNotePackedLen], [maxEventSerializedLen]) {
-        await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(AztecAddress.fromString(contractAddress), Fr.fromString(noteValidationRequestsArrayBaseSlot), Fr.fromString(eventValidationRequestsArrayBaseSlot), Fr.fromString(maxNotePackedLen).toNumber(), Fr.fromString(maxEventSerializedLen).toNumber());
-        return [];
+    aztec_utl_getPendingTaggedLogs(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getPendingTaggedLogs',
+            inputs,
+            handler: ([scope, providedSecrets])=>this.handlerAsUtility().getPendingTaggedLogs(scope, providedSecrets)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_bulkRetrieveLogs([contractAddress], [logRetrievalRequestsArrayBaseSlot], [logRetrievalResponsesArrayBaseSlot]) {
-        await this.handlerAsUtility().bulkRetrieveLogs(AztecAddress.fromString(contractAddress), Fr.fromString(logRetrievalRequestsArrayBaseSlot), Fr.fromString(logRetrievalResponsesArrayBaseSlot));
-        return [];
+    aztec_utl_validateAndStoreEnqueuedNotesAndEvents(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_validateAndStoreEnqueuedNotesAndEvents',
+            inputs,
+            handler: ([noteValidationRequests, eventValidationRequests, scope])=>this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(noteValidationRequests, eventValidationRequests, scope)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_utilityResolveMessageContexts([contractAddress], [messageContextRequestsArrayBaseSlot], [messageContextResponsesArrayBaseSlot]) {
-        await this.handlerAsUtility().utilityResolveMessageContexts(AztecAddress.fromString(contractAddress), Fr.fromString(messageContextRequestsArrayBaseSlot), Fr.fromString(messageContextResponsesArrayBaseSlot));
-        return [];
+    aztec_utl_getLogsByTag(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getLogsByTag',
+            inputs,
+            handler: ([requests])=>this.handlerAsUtility().getLogsByTag(requests)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_storeCapsule([contractAddress], [slot], capsule) {
-        await this.handlerAsUtility().storeCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot), capsule.map(Fr.fromString));
-        return [];
+    aztec_utl_getMessageContextsByTxHash(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getMessageContextsByTxHash',
+            inputs,
+            handler: ([requests])=>this.handlerAsUtility().getMessageContextsByTxHash(requests)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_loadCapsule([contractAddress], [slot], [tSize]) {
-        const values = await this.handlerAsUtility().loadCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot));
-        // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
-        // with two fields: `some` (a boolean) and `value` (a field array in this case).
-        if (values === null) {
-            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
-            return [
-                toACVMField(0),
-                Array(Fr.fromString(tSize).toNumber()).fill(toACVMField(0))
-            ];
-        } else {
-            // Data was found so we set `some` to 1 and return it along with `value`.
-            return [
-                toACVMField(1),
-                values.map(toACVMField)
-            ];
-        }
+    aztec_utl_getTxEffect(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getTxEffect',
+            inputs,
+            handler: ([txHash])=>this.handlerAsUtility().getTxEffect(txHash)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_deleteCapsule([contractAddress], [slot]) {
-        await this.handlerAsUtility().deleteCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot));
-        return [];
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_copyCapsule([contractAddress], [srcSlot], [dstSlot], [numEntries]) {
-        await this.handlerAsUtility().copyCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(srcSlot), Fr.fromString(dstSlot), Fr.fromString(numEntries).toNumber());
-        return [];
-    }
-    // eslint-disable-next-line camelcase
-    async aztec_utl_tryAes128Decrypt(ciphertextBVecStorage, [ciphertextLength], iv, symKey) {
-        const ciphertext = fromUintBoundedVec(ciphertextBVecStorage, ciphertextLength, 8);
-        const ivBuffer = fromUintArray(iv, 8);
-        const symKeyBuffer = fromUintArray(symKey, 8);
-        // Noir Option<BoundedVec> is encoded as [is_some: Field, storage: Field[], length: Field].
-        try {
-            const plaintext = await this.handlerAsUtility().aes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
-            const [storage, length] = bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
-            return [
-                toACVMField(1),
-                storage,
-                length
-            ];
-        } catch  {
-            const zeroStorage = Array(ciphertextBVecStorage.length).fill(toACVMField(0));
-            return [
-                toACVMField(0),
-                zeroStorage,
-                toACVMField(0)
-            ];
-        }
+    aztec_utl_setCapsule(...inputs) {
+        return callHandler({
+            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 callHandler({
+            oracle: 'aztec_utl_getCapsule',
+            inputs,
+            handler: ([contractAddress, slot, tSize, scope])=>this.handlerAsUtility().getCapsule(contractAddress, slot, tSize, scope)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_getSharedSecret([address], [ephPKField0], [ephPKField1], [ephPKField2]) {
-        const secret = await this.handlerAsUtility().getSharedSecret(AztecAddress.fromField(Fr.fromString(address)), Point.fromFields([
-            ephPKField0,
-            ephPKField1,
-            ephPKField2
-        ].map(Fr.fromString)));
-        return secret.toFields().map(toACVMField);
+    aztec_utl_deleteCapsule(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_deleteCapsule',
+            inputs,
+            handler: ([contractAddress, slot, scope])=>{
+                this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope);
+            }
+        });
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_invalidateContractSyncCache([contractAddress], scopes, [scopeCount]) {
-        const scopeAddresses = scopes.slice(0, +scopeCount).map((s)=>AztecAddress.fromField(Fr.fromString(s)));
-        this.handlerAsUtility().invalidateContractSyncCache(AztecAddress.fromField(Fr.fromString(contractAddress)), scopeAddresses);
-        return Promise.resolve([]);
+    aztec_utl_copyCapsule(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_copyCapsule',
+            inputs,
+            handler: ([contractAddress, srcSlot, dstSlot, numEntries, scope])=>this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, scope)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_emitOffchainEffect(data) {
-        await this.handlerAsUtility().emitOffchainEffect(data.map(Fr.fromString));
-        return [];
+    aztec_utl_pushEphemeral(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_pushEphemeral',
+            inputs,
+            handler: ([slot, elements])=>this.handlerAsUtility().pushEphemeral(slot, elements)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_getSenderForTags() {
-        const sender = await this.handlerAsPrivate().getSenderForTags();
-        // Return [1, address] for Some(address), [0, 0] for None
-        return sender ? [
-            toACVMField(1n),
-            toACVMField(sender)
-        ] : [
-            toACVMField(0n),
-            toACVMField(0n)
-        ];
+    aztec_utl_popEphemeral(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_popEphemeral',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().popEphemeral(slot)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getEphemeral(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getEphemeral',
+            inputs,
+            handler: ([slot, index])=>this.handlerAsUtility().getEphemeral(slot, index)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setEphemeral(...inputs) {
+        return callHandler({
+            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 callHandler({
+            oracle: 'aztec_utl_getEphemeralLen',
+            inputs,
+            handler: ([slot])=>this.handlerAsUtility().getEphemeralLen(slot)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_removeEphemeral(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_removeEphemeral',
+            inputs,
+            handler: ([slot, index])=>{
+                this.handlerAsUtility().removeEphemeral(slot, index);
+            }
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_clearEphemeral(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_clearEphemeral',
+            inputs,
+            handler: ([slot])=>{
+                this.handlerAsUtility().clearEphemeral(slot);
+            }
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_decryptAes128(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_decryptAes128',
+            inputs,
+            handler: ([ciphertext, iv, symKey])=>this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey)
+        });
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_setSenderForTags([senderForTags]) {
-        await this.handlerAsPrivate().setSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
-        return [];
+    aztec_utl_getSharedSecrets(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_getSharedSecrets',
+            inputs,
+            handler: ([address, ephPks, contractAddress])=>this.handlerAsUtility().getSharedSecrets(address, ephPks, contractAddress)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_setContractSyncCacheInvalid(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_setContractSyncCacheInvalid',
+            inputs,
+            handler: ([contractAddress, scopes])=>{
+                this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes);
+            }
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_emitOffchainEffect(...inputs) {
+        return callHandler({
+            oracle: 'aztec_utl_emitOffchainEffect',
+            inputs,
+            handler: ([data])=>this.handlerAsUtility().emitOffchainEffect(data)
+        });
+    }
+    // eslint-disable-next-line camelcase
+    aztec_prv_getSenderForTags() {
+        return callHandler({
+            oracle: 'aztec_prv_getSenderForTags',
+            inputs: [],
+            handler: ()=>this.handlerAsPrivate().getSenderForTags()
+        });
     }
 }