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

package/src/contract_function_simulator/oracle/oracle.ts

@@ -1,23 +1,8 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { Point } from '@aztec/foundation/curves/grumpkin';
-import {
-  type ACIRCallback,
-  type ACVMField,
-  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 type { ACIRCallback, ACVMField } from '@aztec/simulator/client';
 
+import { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
 import type { IMiscOracle, IPrivateExecutionOracle, IUtilityExecutionOracle } from './interfaces.js';
-import { buildLegacyOracleCallbacks } from './legacy_oracle_mappings.js';
-import { packAsHintedNote } from './note_packing_utils.js';
+import { callHandler } from './oracle_registry.js';
 
 export class UnavailableOracleError extends Error {
   constructor(oracleName: string) {
@@ -27,9 +12,28 @@ 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 {
-  constructor(private handler: IMiscOracle | IUtilityExecutionOracle | IPrivateExecutionOracle) {}
+  constructor(private handler: IMiscOracle & (IUtilityExecutionOracle | IPrivateExecutionOracle)) {}
 
   private handlerAsMisc(): IMiscOracle {
     if (!('isMisc' in this.handler)) {
@@ -73,9 +77,9 @@ export class Oracle {
     // 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_')) {
+      if (!name.startsWith('aztec_prv_') && !name.startsWith('aztec_utl_') && !name.startsWith('aztec_misc_')) {
         throw new Error(
-          `Oracle function "${name}" must be prefixed with either "aztec_prv_" or "aztec_utl_" to indicate its scope`,
+          `Oracle function "${name}" must be prefixed with "aztec_prv_", "aztec_utl_", or "aztec_misc_" to indicate its scope`,
         );
       }
 
@@ -92,584 +96,616 @@ export class Oracle {
       return acc;
     }, {} as ACIRCallback);
 
-    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: string) {
+        if (prop in target) {
+          return target[prop];
+        }
+        // Return a function that throws with an enhanced error message if applicable
+        return () => {
+          type NonOracleFunctionGetContractOracleVersion = {
+            nonOracleFunctionGetContractOracleVersion(): { major: number; minor: number } | undefined;
+          };
+
+          let contractVersion = undefined;
+          if ('nonOracleFunctionGetContractOracleVersion' in handler) {
+            contractVersion = (
+              handler as unknown as NonOracleFunctionGetContractOracleVersion
+            ).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]: ACVMField[]) {
-    this.handlerAsMisc().assertCompatibleOracleVersion(Fr.fromString(version).toNumber());
-    return Promise.resolve([]);
+  aztec_misc_assertCompatibleOracleVersion(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_misc_assertCompatibleOracleVersion',
+      inputs,
+      handler: ([major, minor]) => {
+        this.handlerAsMisc().assertCompatibleOracleVersion(major, minor);
+      },
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_getRandomField(): Promise<ACVMField[]> {
-    const val = this.handlerAsMisc().getRandomField();
-    return Promise.resolve([toACVMField(val)]);
+  aztec_misc_getRandomField(): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_misc_getRandomField',
+      inputs: [],
+      handler: () => this.handlerAsMisc().getRandomField(),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_prv_storeInExecutionCache(values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
-    this.handlerAsPrivate().storeInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
-    return Promise.resolve([]);
+  aztec_prv_setHashPreimage(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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]: ACVMField[]): Promise<ACVMField[][]> {
-    const values = await this.handlerAsPrivate().loadFromExecutionCache(Fr.fromString(returnsHash));
-    return [values.map(toACVMField)];
+  aztec_prv_getHashPreimage(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_getHashPreimage',
+      inputs,
+      handler: ([returnsHash]) => this.handlerAsPrivate().getHashPreimage(returnsHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
   aztec_utl_getUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
-    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]: ACVMField[]): Promise<ACVMField[]> {
-    const keyValidationRequest = await this.handlerAsUtility().getKeyValidationRequest(Fr.fromString(pkMHash));
-
-    return keyValidationRequest.toFields().map(toACVMField);
+  aztec_utl_getKeyValidationRequest(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getKeyValidationRequest',
+      inputs,
+      handler: ([pkMHash]) => this.handlerAsUtility().getKeyValidationRequest(pkMHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getContractInstance([address]: ACVMField[]): Promise<ACVMField[]> {
-    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: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getContractInstance',
+      inputs,
+      handler: ([address]) => this.handlerAsUtility().getContractInstance(address),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getNoteHashMembershipWitness(
-    [anchorBlockHash]: ACVMField[],
-    [noteHash]: ACVMField[],
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    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: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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]: ACVMField[],
-    [blockHash]: ACVMField[],
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    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: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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]: ACVMField[],
-    [nullifier]: ACVMField[], // nullifier, we try to find the witness for (to prove inclusion)
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockHash = BlockHash.fromString(blockHash);
-    const parsedNullifier = Fr.fromString(nullifier);
+  aztec_utl_getNullifierMembershipWitness(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getNullifierMembershipWitness',
+      inputs,
+      handler: ([blockHash, nullifier]) => this.handlerAsUtility().getNullifierMembershipWitness(blockHash, 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();
+  // eslint-disable-next-line camelcase
+  aztec_utl_getLowNullifierMembershipWitness(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getLowNullifierMembershipWitness',
+      inputs,
+      handler: ([blockHash, nullifier]) =>
+        this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getLowNullifierMembershipWitness(
-    [blockHash]: ACVMField[],
-    [nullifier]: ACVMField[], // nullifier, we try to find the low nullifier witness for (to prove non-inclusion)
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockHash = BlockHash.fromString(blockHash);
-    const parsedNullifier = Fr.fromString(nullifier);
+  aztec_utl_getPublicDataWitness(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getPublicDataWitness',
+      inputs,
+      handler: ([blockHash, leafSlot]) => this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot),
+    });
+  }
 
-    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();
+  // eslint-disable-next-line camelcase
+  aztec_utl_getBlockHeader(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getBlockHeader',
+      inputs,
+      handler: ([blockNumber]) => this.handlerAsUtility().getBlockHeader(blockNumber),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getPublicDataWitness(
-    [blockHash]: ACVMField[],
-    [leafSlot]: ACVMField[],
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockHash = BlockHash.fromString(blockHash);
-    const parsedLeafSlot = Fr.fromString(leafSlot);
+  aztec_utl_getAuthWitness(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getAuthWitness',
+      inputs,
+      handler: ([messageHash]) => this.handlerAsUtility().getAuthWitness(messageHash),
+    });
+  }
 
-    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();
+  // eslint-disable-next-line camelcase
+  aztec_utl_getPublicKeysAndPartialAddress(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getPublicKeysAndPartialAddress',
+      inputs,
+      handler: ([address]) => this.handlerAsUtility().getPublicKeysAndPartialAddress(address),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getBlockHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+  aztec_utl_getNotes(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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,
+        ),
+    });
+  }
 
-    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);
+  // eslint-disable-next-line camelcase
+  aztec_prv_notifyCreatedNote(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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_utl_getAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[][]> {
-    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_prv_notifyNullifiedNote(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_notifyNullifiedNote',
+      inputs,
+      handler: ([innerNullifier, noteHash, counter]) =>
+        this.handlerAsPrivate().notifyNullifiedNote(innerNullifier, noteHash, counter),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_tryGetPublicKeysAndPartialAddress([address]: ACVMField[]): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
-    const result = await this.handlerAsUtility().tryGetPublicKeysAndPartialAddress(parsedAddress);
+  aztec_prv_notifyCreatedNullifier(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_notifyCreatedNullifier',
+      inputs,
+      handler: ([innerNullifier]) => this.handlerAsPrivate().notifyCreatedNullifier(innerNullifier),
+    });
+  }
 
-    // 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)];
-    }
+  // eslint-disable-next-line camelcase
+  aztec_prv_isNullifierPending(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_isNullifierPending',
+      inputs,
+      handler: ([innerNullifier, contractAddress]) =>
+        this.handlerAsPrivate().isNullifierPending(innerNullifier, contractAddress),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getNotes(
-    [ownerSome]: ACVMField[],
-    [ownerValue]: ACVMField[],
-    [storageSlot]: ACVMField[],
-    [numSelects]: ACVMField[],
-    selectByIndexes: ACVMField[],
-    selectByOffsets: ACVMField[],
-    selectByLengths: ACVMField[],
-    selectValues: ACVMField[],
-    selectComparators: ACVMField[],
-    sortByIndexes: ACVMField[],
-    sortByOffsets: ACVMField[],
-    sortByLengths: ACVMField[],
-    sortOrder: ACVMField[],
-    [limit]: ACVMField[],
-    [offset]: ACVMField[],
-    [status]: ACVMField[],
-    [maxNotes]: ACVMField[],
-    [packedHintedNoteLength]: ACVMField[],
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    // 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,
-    );
+  aztec_utl_doesNullifierExist(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_doesNullifierExist',
+      inputs,
+      handler: ([innerNullifier]) => this.handlerAsUtility().doesNullifierExist(innerNullifier),
+    });
+  }
 
-    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,
-      }),
-    );
+  // eslint-disable-next-line camelcase
+  aztec_utl_getL1ToL2MembershipWitness(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getL1ToL2MembershipWitness',
+      inputs,
+      handler: ([contractAddress, messageHash, secret]) =>
+        this.handlerAsUtility().getL1ToL2MembershipWitness(contractAddress, messageHash, secret),
+    });
+  }
 
-    // Now we convert each sub-array to an array of ACVMField
-    const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedHintedNotes.map(subArray =>
-      subArray.map(toACVMField),
-    );
+  // eslint-disable-next-line camelcase
+  aztec_utl_getFromPublicStorage(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getFromPublicStorage',
+      inputs,
+      handler: ([blockHash, contractAddress, startStorageSlot, numberOfElements]) =>
+        this.handlerAsUtility().getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements),
+    });
+  }
 
-    // At last we convert the array of arrays to a bounded vec of arrays
-    return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedHintedNoteLength);
-  }
-
-  // eslint-disable-next-line camelcase
-  aztec_prv_notifyCreatedNote(
-    [owner]: ACVMField[],
-    [storageSlot]: ACVMField[],
-    [randomness]: ACVMField[],
-    [noteTypeId]: ACVMField[],
-    note: ACVMField[],
-    [noteHash]: ACVMField[],
-    [counter]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    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([]);
+  // eslint-disable-next-line camelcase
+  aztec_utl_callUtilityFunction(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_callUtilityFunction',
+      inputs,
+      handler: ([contractAddress, functionSelector, args]) =>
+        this.handlerAsUtility().callUtilityFunction(contractAddress, functionSelector, args),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_notifyNullifiedNote(
-    [innerNullifier]: ACVMField[],
-    [noteHash]: ACVMField[],
-    [counter]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().notifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
-    return [];
+  aztec_prv_notifyCreatedContractClassLog(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_notifyCreatedContractClassLog',
+      inputs,
+      handler: ([log, counter]) => {
+        this.handlerAsPrivate().notifyCreatedContractClassLog(log, counter);
+      },
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_notifyCreatedNullifier([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().notifyCreatedNullifier(Fr.fromString(innerNullifier));
-    return [];
+  aztec_misc_log(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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_isNullifierPending(
-    [innerNullifier]: ACVMField[],
-    [contractAddress]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    const isPending = await this.handlerAsPrivate().isNullifierPending(
-      Fr.fromString(innerNullifier),
-      AztecAddress.fromString(contractAddress),
-    );
-    return [toACVMField(isPending)];
+  aztec_prv_callPrivateFunction(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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_utl_checkNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
-    const exists = await this.handlerAsUtility().checkNullifierExists(Fr.fromString(innerNullifier));
-    return [toACVMField(exists)];
+  aztec_prv_assertValidPublicCalldata(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_assertValidPublicCalldata',
+      inputs,
+      handler: ([calldataHash]) => this.handlerAsPrivate().assertValidPublicCalldata(calldataHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getL1ToL2MembershipWitness(
-    [contractAddress]: ACVMField[],
-    [messageHash]: ACVMField[],
-    [secret]: ACVMField[],
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    const message = await this.handlerAsUtility().getL1ToL2MembershipWitness(
-      AztecAddress.fromString(contractAddress),
-      Fr.fromString(messageHash),
-      Fr.fromString(secret),
-    );
-    return message.toNoirRepresentation();
+  aztec_prv_notifyRevertiblePhaseStart(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_notifyRevertiblePhaseStart',
+      inputs,
+      handler: ([minRevertibleSideEffectCounter]) =>
+        this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_storageRead(
-    [blockHash]: ACVMField[],
-    [contractAddress]: ACVMField[],
-    [startStorageSlot]: ACVMField[],
-    [numberOfElements]: ACVMField[],
-  ): Promise<ACVMField[][]> {
-    const values = await this.handlerAsUtility().storageRead(
-      BlockHash.fromString(blockHash),
-      new AztecAddress(Fr.fromString(contractAddress)),
-      Fr.fromString(startStorageSlot),
-      +numberOfElements,
-    );
-    return [values.map(toACVMField)];
+  aztec_prv_isExecutionInRevertiblePhase(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_isExecutionInRevertiblePhase',
+      inputs,
+      handler: ([sideEffectCounter]) => this.handlerAsPrivate().isExecutionInRevertiblePhase(sideEffectCounter),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_prv_notifyCreatedContractClassLog(
-    [contractAddress]: ACVMField[],
-    message: ACVMField[],
-    [length]: ACVMField[],
-    [counter]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    const logFields = new ContractClassLogFields(message.map(Fr.fromString));
-    const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
+  aztec_prv_getAppTaggingSecret(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_getAppTaggingSecret',
+      inputs,
+      handler: ([sender, recipient]) => this.handlerAsPrivate().getAppTaggingSecret(sender, recipient),
+    });
+  }
 
-    this.handlerAsPrivate().notifyCreatedContractClassLog(log, +counter);
-    return Promise.resolve([]);
+  // eslint-disable-next-line camelcase
+  aztec_prv_getNextTaggingIndex(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_getNextTaggingIndex',
+      inputs,
+      handler: ([secret, mode]) => this.handlerAsPrivate().getNextTaggingIndex(secret, mode),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_log(
-    level: ACVMField[],
-    message: ACVMField[],
-    _ignoredFieldsSize: ACVMField[],
-    fields: ACVMField[],
-  ): Promise<ACVMField[]> {
-    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_utl_getPendingTaggedLogs(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getPendingTaggedLogs',
+      inputs,
+      handler: ([scope, providedSecrets]) => this.handlerAsUtility().getPendingTaggedLogs(scope, providedSecrets),
+    });
   }
 
-  // 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]: ACVMField[],
-    [functionSelector]: ACVMField[],
-    [argsHash]: ACVMField[],
-    [sideEffectCounter]: ACVMField[],
-    [isStaticCall]: ACVMField[],
-  ): Promise<ACVMField[][]> {
-    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_utl_validateAndStoreEnqueuedNotesAndEvents(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_validateAndStoreEnqueuedNotesAndEvents',
+      inputs,
+      handler: ([noteValidationRequests, eventValidationRequests, scope]) =>
+        this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
+          noteValidationRequests,
+          eventValidationRequests,
+          scope,
+        ),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_validatePublicCalldata([calldataHash]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().validatePublicCalldata(Fr.fromString(calldataHash));
-    return [];
+  aztec_utl_getLogsByTag(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getLogsByTag',
+      inputs,
+      handler: ([requests]) => this.handlerAsUtility().getLogsByTag(requests),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_notifyRevertiblePhaseStart([minRevertibleSideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().notifyRevertiblePhaseStart(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
-    return Promise.resolve([]);
+  aztec_utl_getMessageContextsByTxHash(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getMessageContextsByTxHash',
+      inputs,
+      handler: ([requests]) => this.handlerAsUtility().getMessageContextsByTxHash(requests),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_inRevertiblePhase([sideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
-    const isRevertible = await this.handlerAsPrivate().inRevertiblePhase(Fr.fromString(sideEffectCounter).toNumber());
-    return Promise.resolve([toACVMField(isRevertible)]);
+  aztec_utl_getTxEffect(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getTxEffect',
+      inputs,
+      handler: ([txHash]) => this.handlerAsUtility().getTxEffect(txHash),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_getNextAppTagAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
-    const tag = await this.handlerAsPrivate().getNextAppTagAsSender(
-      AztecAddress.fromString(sender),
-      AztecAddress.fromString(recipient),
-    );
-    return [toACVMField(tag.value)];
+  aztec_utl_setCapsule(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_setCapsule',
+      inputs,
+      handler: ([contractAddress, slot, capsule, scope]) => {
+        this.handlerAsUtility().setCapsule(contractAddress, slot, capsule, scope);
+      },
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_fetchTaggedLogs([pendingTaggedLogArrayBaseSlot]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsUtility().fetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
-    return [];
+  aztec_utl_getCapsule(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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_validateAndStoreEnqueuedNotesAndEvents(
-    [contractAddress]: ACVMField[],
-    [noteValidationRequestsArrayBaseSlot]: ACVMField[],
-    [eventValidationRequestsArrayBaseSlot]: ACVMField[],
-    [maxNotePackedLen]: ACVMField[],
-    [maxEventSerializedLen]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
-      AztecAddress.fromString(contractAddress),
-      Fr.fromString(noteValidationRequestsArrayBaseSlot),
-      Fr.fromString(eventValidationRequestsArrayBaseSlot),
-      Fr.fromString(maxNotePackedLen).toNumber(),
-      Fr.fromString(maxEventSerializedLen).toNumber(),
-    );
+  aztec_utl_deleteCapsule(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_deleteCapsule',
+      inputs,
+      handler: ([contractAddress, slot, scope]) => {
+        this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope);
+      },
+    });
+  }
 
-    return [];
+  // eslint-disable-next-line camelcase
+  aztec_utl_copyCapsule(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    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_bulkRetrieveLogs(
-    [contractAddress]: ACVMField[],
-    [logRetrievalRequestsArrayBaseSlot]: ACVMField[],
-    [logRetrievalResponsesArrayBaseSlot]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().bulkRetrieveLogs(
-      AztecAddress.fromString(contractAddress),
-      Fr.fromString(logRetrievalRequestsArrayBaseSlot),
-      Fr.fromString(logRetrievalResponsesArrayBaseSlot),
-    );
-    return [];
+  aztec_utl_pushEphemeral(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_pushEphemeral',
+      inputs,
+      handler: ([slot, elements]) => this.handlerAsUtility().pushEphemeral(slot, elements),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_utilityResolveMessageContexts(
-    [contractAddress]: ACVMField[],
-    [messageContextRequestsArrayBaseSlot]: ACVMField[],
-    [messageContextResponsesArrayBaseSlot]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().utilityResolveMessageContexts(
-      AztecAddress.fromString(contractAddress),
-      Fr.fromString(messageContextRequestsArrayBaseSlot),
-      Fr.fromString(messageContextResponsesArrayBaseSlot),
-    );
-    return [];
+  aztec_utl_popEphemeral(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_popEphemeral',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().popEphemeral(slot),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_storeCapsule(
-    [contractAddress]: ACVMField[],
-    [slot]: ACVMField[],
-    capsule: ACVMField[],
-  ): Promise<ACVMField[]> {
-    await this.handlerAsUtility().storeCapsule(
-      AztecAddress.fromField(Fr.fromString(contractAddress)),
-      Fr.fromString(slot),
-      capsule.map(Fr.fromString),
-    );
-    return [];
+  aztec_utl_getEphemeral(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getEphemeral',
+      inputs,
+      handler: ([slot, index]) => this.handlerAsUtility().getEphemeral(slot, index),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_loadCapsule(
-    [contractAddress]: ACVMField[],
-    [slot]: ACVMField[],
-    [tSize]: ACVMField[],
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    const values = await this.handlerAsUtility().loadCapsule(
-      AztecAddress.fromField(Fr.fromString(contractAddress)),
-      Fr.fromString(slot),
-    );
+  aztec_utl_setEphemeral(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_setEphemeral',
+      inputs,
+      handler: ([slot, index, elements]) => {
+        this.handlerAsUtility().setEphemeral(slot, index, elements);
+      },
+    });
+  }
 
-    // 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)];
-    }
+  // eslint-disable-next-line camelcase
+  aztec_utl_getEphemeralLen(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getEphemeralLen',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().getEphemeralLen(slot),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_deleteCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsUtility().deleteCapsule(
-      AztecAddress.fromField(Fr.fromString(contractAddress)),
-      Fr.fromString(slot),
-    );
-    return [];
+  aztec_utl_removeEphemeral(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_removeEphemeral',
+      inputs,
+      handler: ([slot, index]) => {
+        this.handlerAsUtility().removeEphemeral(slot, index);
+      },
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_copyCapsule(
-    [contractAddress]: ACVMField[],
-    [srcSlot]: ACVMField[],
-    [dstSlot]: ACVMField[],
-    [numEntries]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    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: ACVMField[],
-    [ciphertextLength]: ACVMField[],
-    iv: ACVMField[],
-    symKey: ACVMField[],
-  ): Promise<(ACVMField | ACVMField[])[]> {
-    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_clearEphemeral(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_clearEphemeral',
+      inputs,
+      handler: ([slot]) => {
+        this.handlerAsUtility().clearEphemeral(slot);
+      },
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getSharedSecret(
-    [address]: ACVMField[],
-    [ephPKField0]: ACVMField[],
-    [ephPKField1]: ACVMField[],
-    [ephPKField2]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    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_decryptAes128(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_decryptAes128',
+      inputs,
+      handler: ([ciphertext, iv, symKey]) => this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_invalidateContractSyncCache(
-    [contractAddress]: ACVMField[],
-    scopes: ACVMField[],
-    [scopeCount]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    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_getSharedSecrets(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_getSharedSecrets',
+      inputs,
+      handler: ([address, ephPks, contractAddress]) =>
+        this.handlerAsUtility().getSharedSecrets(address, ephPks, contractAddress),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_emitOffchainEffect(data: ACVMField[]) {
-    await this.handlerAsUtility().emitOffchainEffect(data.map(Fr.fromString));
-    return [];
+  aztec_utl_setContractSyncCacheInvalid(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_setContractSyncCacheInvalid',
+      inputs,
+      handler: ([contractAddress, scopes]) => {
+        this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes);
+      },
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_getSenderForTags(): Promise<ACVMField[]> {
-    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_emitOffchainEffect(...inputs: ACVMField[][]): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_utl_emitOffchainEffect',
+      inputs,
+      handler: ([data]) => this.handlerAsUtility().emitOffchainEffect(data),
+    });
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_setSenderForTags([senderForTags]: ACVMField[]): Promise<ACVMField[]> {
-    await this.handlerAsPrivate().setSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
-    return [];
+  aztec_prv_getSenderForTags(): Promise<(ACVMField | ACVMField[])[]> {
+    return callHandler({
+      oracle: 'aztec_prv_getSenderForTags',
+      inputs: [],
+      handler: () => this.handlerAsPrivate().getSenderForTags(),
+    });
   }
 }