@aztec/simulator 0.81.0 → 0.82.1-alpha-testnet.1

package/src/private/acvm/oracle/oracle.ts

@@ -5,14 +5,7 @@ import { ContractClassLog, LogWithTxData } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
 import type { ACVMField } from '../acvm_types.js';
-import {
-  frToBoolean,
-  frToNumber,
-  fromACVMField,
-  fromBoundedVec,
-  fromUintArray,
-  fromUintBoundedVec,
-} from '../deserialize.js';
+import { fromBoundedVec, fromUintArray, fromUintBoundedVec } from '../deserialize.js';
 import { bufferToBoundedVec, toACVMField, toACVMFieldSingleOrArray } from '../serialize.js';
 import type { TypedOracle } from './typed_oracle.js';
 
@@ -22,46 +15,46 @@ import type { TypedOracle } from './typed_oracle.js';
 export class Oracle {
   constructor(private typedOracle: TypedOracle) {}
 
-  getRandomField(): ACVMField {
+  getRandomField(): Promise<ACVMField[]> {
     const val = this.typedOracle.getRandomField();
-    return toACVMField(val);
+    return Promise.resolve([toACVMField(val)]);
   }
 
   // Since the argument is a slice, noir automatically adds a length field to oracle call.
-  async storeInExecutionCache(_length: ACVMField[], values: ACVMField[]): Promise<ACVMField> {
-    const hash = await this.typedOracle.storeInExecutionCache(values.map(fromACVMField));
-    return toACVMField(hash);
+  storeInExecutionCache(_length: ACVMField[], values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
+    this.typedOracle.storeInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
+    return Promise.resolve([]);
   }
 
-  async loadFromExecutionCache([returnsHash]: ACVMField[]): Promise<ACVMField[]> {
-    const values = await this.typedOracle.loadFromExecutionCache(fromACVMField(returnsHash));
-    return values.map(toACVMField);
+  async loadFromExecutionCache([returnsHash]: ACVMField[]): Promise<ACVMField[][]> {
+    const values = await this.typedOracle.loadFromExecutionCache(Fr.fromString(returnsHash));
+    return [values.map(toACVMField)];
   }
 
-  async getBlockNumber(): Promise<ACVMField> {
-    return toACVMField(await this.typedOracle.getBlockNumber());
+  async getBlockNumber(): Promise<ACVMField[]> {
+    return [toACVMField(await this.typedOracle.getBlockNumber())];
   }
 
-  async getContractAddress(): Promise<ACVMField> {
-    return toACVMField(await this.typedOracle.getContractAddress());
+  async getContractAddress(): Promise<ACVMField[]> {
+    return [toACVMField(await this.typedOracle.getContractAddress())];
   }
 
-  async getVersion(): Promise<ACVMField> {
-    return toACVMField(await this.typedOracle.getVersion());
+  async getVersion(): Promise<ACVMField[]> {
+    return [toACVMField(await this.typedOracle.getVersion())];
   }
 
-  async getChainId(): Promise<ACVMField> {
-    return toACVMField(await this.typedOracle.getChainId());
+  async getChainId(): Promise<ACVMField[]> {
+    return [toACVMField(await this.typedOracle.getChainId())];
   }
 
   async getKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
-    const { pkM, skApp } = await this.typedOracle.getKeyValidationRequest(fromACVMField(pkMHash));
+    const keyValidationRequest = await this.typedOracle.getKeyValidationRequest(Fr.fromString(pkMHash));
 
-    return [toACVMField(pkM.x), toACVMField(pkM.y), toACVMField(pkM.isInfinite), toACVMField(skApp)];
+    return keyValidationRequest.toFields().map(toACVMField);
   }
 
-  async getContractInstance([address]: ACVMField[]) {
-    const instance = await this.typedOracle.getContractInstance(AztecAddress.fromField(fromACVMField(address)));
+  async getContractInstance([address]: ACVMField[]): Promise<ACVMField[]> {
+    const instance = await this.typedOracle.getContractInstance(AztecAddress.fromField(Fr.fromString(address)));
 
     return [
       instance.salt,
@@ -76,10 +69,10 @@ export class Oracle {
     [blockNumber]: ACVMField[],
     [treeId]: ACVMField[],
     [leafValue]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
-    const parsedTreeId = frToNumber(fromACVMField(treeId));
-    const parsedLeafValue = fromACVMField(leafValue);
+  ): Promise<(ACVMField | ACVMField[])[]> {
+    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedTreeId = Fr.fromString(treeId).toNumber();
+    const parsedLeafValue = Fr.fromString(leafValue);
 
     const witness = await this.typedOracle.getMembershipWitness(parsedBlockNumber, parsedTreeId, parsedLeafValue);
     if (!witness) {
@@ -87,29 +80,29 @@ export class Oracle {
         `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block ${parsedBlockNumber}.`,
       );
     }
-    return witness.map(toACVMField);
+    return [toACVMField(witness[0]), witness.slice(1).map(toACVMField)];
   }
 
   async getNullifierMembershipWitness(
     [blockNumber]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the witness for (to prove inclusion)
-  ): Promise<ACVMField[]> {
-    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
-    const parsedNullifier = fromACVMField(nullifier);
+  ): Promise<(ACVMField | ACVMField[])[]> {
+    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.typedOracle.getNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
     if (!witness) {
       throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
     }
-    return witness.toFields().map(toACVMField);
+    return witness.toNoirRepresentation();
   }
 
   async getLowNullifierMembershipWitness(
     [blockNumber]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the low nullifier witness for (to prove non-inclusion)
-  ): Promise<ACVMField[]> {
-    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
-    const parsedNullifier = fromACVMField(nullifier);
+  ): Promise<(ACVMField | ACVMField[])[]> {
+    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.typedOracle.getLowNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
     if (!witness) {
@@ -117,22 +110,25 @@ export class Oracle {
         `Low nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`,
       );
     }
-    return witness.toFields().map(toACVMField);
+    return witness.toNoirRepresentation();
   }
 
-  async getPublicDataTreeWitness([blockNumber]: ACVMField[], [leafSlot]: ACVMField[]): Promise<ACVMField[]> {
-    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
-    const parsedLeafSlot = fromACVMField(leafSlot);
+  async getPublicDataWitness(
+    [blockNumber]: ACVMField[],
+    [leafSlot]: ACVMField[],
+  ): Promise<(ACVMField | ACVMField[])[]> {
+    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedLeafSlot = Fr.fromString(leafSlot);
 
-    const witness = await this.typedOracle.getPublicDataTreeWitness(parsedBlockNumber, parsedLeafSlot);
+    const witness = await this.typedOracle.getPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
     if (!witness) {
       throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
     }
-    return witness.toFields().map(toACVMField);
+    return witness.toNoirRepresentation();
   }
 
   async getBlockHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]> {
-    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
+    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
 
     const header = await this.typedOracle.getBlockHeader(parsedBlockNumber);
     if (!header) {
@@ -141,20 +137,20 @@ export class Oracle {
     return header.toFields().map(toACVMField);
   }
 
-  async getAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[]> {
-    const messageHashField = fromACVMField(messageHash);
+  async getAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[][]> {
+    const messageHashField = Fr.fromString(messageHash);
     const witness = await this.typedOracle.getAuthWitness(messageHashField);
     if (!witness) {
       throw new Error(`Unknown auth witness for message hash ${messageHashField}`);
     }
-    return witness.map(toACVMField);
+    return [witness.map(toACVMField)];
   }
 
-  async getPublicKeysAndPartialAddress([address]: ACVMField[]): Promise<ACVMField[]> {
-    const parsedAddress = AztecAddress.fromField(fromACVMField(address));
+  async getPublicKeysAndPartialAddress([address]: ACVMField[]): Promise<ACVMField[][]> {
+    const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
     const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
 
-    return [...publicKeys.toFields(), partialAddress].map(toACVMField);
+    return [[...publicKeys.toFields(), partialAddress].map(toACVMField)];
   }
 
   async getNotes(
@@ -173,14 +169,14 @@ export class Oracle {
     [offset]: ACVMField[],
     [status]: ACVMField[],
     [returnSize]: ACVMField[],
-  ): Promise<ACVMField[]> {
+  ): Promise<ACVMField[][]> {
     const noteDatas = await this.typedOracle.getNotes(
-      fromACVMField(storageSlot),
+      Fr.fromString(storageSlot),
       +numSelects,
       selectByIndexes.map(s => +s),
       selectByOffsets.map(s => +s),
       selectByLengths.map(s => +s),
-      selectValues.map(fromACVMField),
+      selectValues.map(Fr.fromString),
       selectComparators.map(s => +s),
       sortByIndexes.map(s => +s),
       sortByOffsets.map(s => +s),
@@ -216,7 +212,7 @@ export class Oracle {
     }
 
     const paddedZeros = Array(returnFieldSize - returnData.length).fill(toACVMField(0));
-    return returnData.concat(paddedZeros);
+    return [returnData.concat(paddedZeros)];
   }
 
   notifyCreatedNote(
@@ -225,47 +221,47 @@ export class Oracle {
     note: ACVMField[],
     [noteHash]: ACVMField[],
     [counter]: ACVMField[],
-  ): ACVMField {
+  ): Promise<ACVMField[]> {
     this.typedOracle.notifyCreatedNote(
-      fromACVMField(storageSlot),
-      NoteSelector.fromField(fromACVMField(noteTypeId)),
-      note.map(fromACVMField),
-      fromACVMField(noteHash),
+      Fr.fromString(storageSlot),
+      NoteSelector.fromField(Fr.fromString(noteTypeId)),
+      note.map(Fr.fromString),
+      Fr.fromString(noteHash),
       +counter,
     );
-    return toACVMField(0);
+    return Promise.resolve([]);
   }
 
   async notifyNullifiedNote(
     [innerNullifier]: ACVMField[],
     [noteHash]: ACVMField[],
     [counter]: ACVMField[],
-  ): Promise<ACVMField> {
-    await this.typedOracle.notifyNullifiedNote(fromACVMField(innerNullifier), fromACVMField(noteHash), +counter);
-    return toACVMField(0);
+  ): Promise<ACVMField[]> {
+    await this.typedOracle.notifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
+    return [];
   }
 
-  async notifyCreatedNullifier([innerNullifier]: ACVMField[]): Promise<ACVMField> {
-    await this.typedOracle.notifyCreatedNullifier(fromACVMField(innerNullifier));
-    return toACVMField(0);
+  async notifyCreatedNullifier([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
+    await this.typedOracle.notifyCreatedNullifier(Fr.fromString(innerNullifier));
+    return [];
   }
 
-  async checkNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField> {
-    const exists = await this.typedOracle.checkNullifierExists(fromACVMField(innerNullifier));
-    return toACVMField(exists);
+  async checkNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
+    const exists = await this.typedOracle.checkNullifierExists(Fr.fromString(innerNullifier));
+    return [toACVMField(exists)];
   }
 
   async getL1ToL2MembershipWitness(
     [contractAddress]: ACVMField[],
     [messageHash]: ACVMField[],
     [secret]: ACVMField[],
-  ): Promise<ACVMField[]> {
+  ): Promise<(ACVMField | ACVMField[])[]> {
     const message = await this.typedOracle.getL1ToL2MembershipWitness(
       AztecAddress.fromString(contractAddress),
-      fromACVMField(messageHash),
-      fromACVMField(secret),
+      Fr.fromString(messageHash),
+      Fr.fromString(secret),
     );
-    return message.toFields().map(toACVMField);
+    return message.toNoirRepresentation();
   }
 
   async storageRead(
@@ -273,32 +269,38 @@ export class Oracle {
     [startStorageSlot]: ACVMField[],
     [blockNumber]: ACVMField[],
     [numberOfElements]: ACVMField[],
-  ): Promise<ACVMField[]> {
+  ): Promise<ACVMField[][]> {
     const values = await this.typedOracle.storageRead(
-      new AztecAddress(fromACVMField(contractAddress)),
-      fromACVMField(startStorageSlot),
+      new AztecAddress(Fr.fromString(contractAddress)),
+      Fr.fromString(startStorageSlot),
       +blockNumber,
       +numberOfElements,
     );
-    return values.map(toACVMField);
+    return [values.map(toACVMField)];
   }
 
   async storageWrite([startStorageSlot]: ACVMField[], values: ACVMField[]): Promise<ACVMField[]> {
-    const newValues = await this.typedOracle.storageWrite(fromACVMField(startStorageSlot), values.map(fromACVMField));
+    const newValues = await this.typedOracle.storageWrite(Fr.fromString(startStorageSlot), values.map(Fr.fromString));
     return newValues.map(toACVMField);
   }
 
-  notifyCreatedContractClassLog([contractAddress]: ACVMField[], message: ACVMField[], [counter]: ACVMField[]): void {
-    const logPayload = message.map(fromACVMField);
-    const log = new ContractClassLog(new AztecAddress(fromACVMField(contractAddress)), logPayload);
+  notifyCreatedContractClassLog(
+    [contractAddress]: ACVMField[],
+    message: ACVMField[],
+    [counter]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const logPayload = message.map(Fr.fromString);
+    const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logPayload);
 
     this.typedOracle.notifyCreatedContractClassLog(log, +counter);
+    return Promise.resolve([]);
   }
 
-  debugLog(message: ACVMField[], _ignoredFieldsSize: ACVMField[], fields: ACVMField[]): void {
-    const messageStr = message.map(acvmField => String.fromCharCode(fromACVMField(acvmField).toNumber())).join('');
-    const fieldsFr = fields.map(fromACVMField);
+  debugLog(message: ACVMField[], _ignoredFieldsSize: ACVMField[], fields: ACVMField[]): Promise<ACVMField[]> {
+    const messageStr = message.map(acvmField => String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
+    const fieldsFr = fields.map(Fr.fromString);
     this.typedOracle.debugLog(messageStr, fieldsFr);
+    return Promise.resolve([]);
   }
 
   async callPrivateFunction(
@@ -307,72 +309,71 @@ export class Oracle {
     [argsHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
-  ): Promise<ACVMField[]> {
+  ): Promise<ACVMField[][]> {
     const { endSideEffectCounter, returnsHash } = await this.typedOracle.callPrivateFunction(
-      AztecAddress.fromField(fromACVMField(contractAddress)),
-      FunctionSelector.fromField(fromACVMField(functionSelector)),
-      fromACVMField(argsHash),
-      frToNumber(fromACVMField(sideEffectCounter)),
-      frToBoolean(fromACVMField(isStaticCall)),
+      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);
+    return [[endSideEffectCounter, returnsHash].map(toACVMField)];
   }
 
-  async enqueuePublicFunctionCall(
+  async notifyEnqueuedPublicFunctionCall(
     [contractAddress]: ACVMField[],
-    [functionSelector]: ACVMField[],
-    [argsHash]: ACVMField[],
+    [calldataHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
-  ): Promise<ACVMField> {
-    const newArgsHash = await this.typedOracle.enqueuePublicFunctionCall(
+  ): Promise<ACVMField[]> {
+    await this.typedOracle.notifyEnqueuedPublicFunctionCall(
       AztecAddress.fromString(contractAddress),
-      FunctionSelector.fromField(fromACVMField(functionSelector)),
-      fromACVMField(argsHash),
-      frToNumber(fromACVMField(sideEffectCounter)),
-      frToBoolean(fromACVMField(isStaticCall)),
+      Fr.fromString(calldataHash),
+      Fr.fromString(sideEffectCounter).toNumber(),
+      Fr.fromString(isStaticCall).toBool(),
     );
-    return toACVMField(newArgsHash);
+    return [];
   }
 
-  async setPublicTeardownFunctionCall(
+  async notifySetPublicTeardownFunctionCall(
     [contractAddress]: ACVMField[],
-    [functionSelector]: ACVMField[],
-    [argsHash]: ACVMField[],
+    [calldataHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
-  ): Promise<ACVMField> {
-    const newArgsHash = await this.typedOracle.setPublicTeardownFunctionCall(
+  ): Promise<ACVMField[]> {
+    await this.typedOracle.notifySetPublicTeardownFunctionCall(
       AztecAddress.fromString(contractAddress),
-      FunctionSelector.fromField(fromACVMField(functionSelector)),
-      fromACVMField(argsHash),
-      frToNumber(fromACVMField(sideEffectCounter)),
-      frToBoolean(fromACVMField(isStaticCall)),
+      Fr.fromString(calldataHash),
+      Fr.fromString(sideEffectCounter).toNumber(),
+      Fr.fromString(isStaticCall).toBool(),
     );
-    return toACVMField(newArgsHash);
+    return [];
   }
 
-  notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]) {
-    this.typedOracle.notifySetMinRevertibleSideEffectCounter(frToNumber(fromACVMField(minRevertibleSideEffectCounter)));
+  notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
+    this.typedOracle.notifySetMinRevertibleSideEffectCounter(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
+    return Promise.resolve([]);
   }
 
-  async getIndexedTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
+  async getIndexedTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[][]> {
     const taggingSecret = await this.typedOracle.getIndexedTaggingSecretAsSender(
       AztecAddress.fromString(sender),
       AztecAddress.fromString(recipient),
     );
-    return taggingSecret.toFields().map(toACVMField);
+    return [taggingSecret.toFields().map(toACVMField)];
   }
 
-  async incrementAppTaggingSecretIndexAsSender([sender]: ACVMField[], [recipient]: ACVMField[]) {
+  async incrementAppTaggingSecretIndexAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
     await this.typedOracle.incrementAppTaggingSecretIndexAsSender(
       AztecAddress.fromString(sender),
       AztecAddress.fromString(recipient),
     );
+    return [];
   }
 
-  async syncNotes() {
+  async syncNotes(): Promise<ACVMField[]> {
     await this.typedOracle.syncNotes();
+    return [];
   }
 
   async deliverNote(
@@ -385,26 +386,26 @@ export class Oracle {
     [nullifier]: ACVMField[],
     [txHash]: ACVMField[],
     [recipient]: ACVMField[],
-  ): Promise<ACVMField> {
+  ): Promise<ACVMField[]> {
     // TODO(#10728): try-catch this block and return false if we get an exception so that the contract can decide what
     // to do if a note fails delivery (e.g. not increment the tagging index, or add it to some pending work list).
     // Delivery might fail due to temporary issues, such as poor node connectivity.
     await this.typedOracle.deliverNote(
       AztecAddress.fromString(contractAddress),
-      fromACVMField(storageSlot),
-      fromACVMField(nonce),
+      Fr.fromString(storageSlot),
+      Fr.fromString(nonce),
       fromBoundedVec(content, contentLength),
-      fromACVMField(noteHash),
-      fromACVMField(nullifier),
-      fromACVMField(txHash),
+      Fr.fromString(noteHash),
+      Fr.fromString(nullifier),
+      Fr.fromString(txHash),
       AztecAddress.fromString(recipient),
     );
 
-    return toACVMField(true);
+    return [toACVMField(true)];
   }
 
   async getLogByTag([tag]: ACVMField[]): Promise<(ACVMField | ACVMField[])[]> {
-    const log = await this.typedOracle.getLogByTag(fromACVMField(tag));
+    const log = await this.typedOracle.getLogByTag(Fr.fromString(tag));
 
     if (log == null) {
       return [toACVMField(0), ...LogWithTxData.noirSerializationOfEmpty().map(toACVMFieldSingleOrArray)];
@@ -413,12 +414,13 @@ export class Oracle {
     }
   }
 
-  async storeCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[], capsule: ACVMField[]) {
+  async storeCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[], capsule: ACVMField[]): Promise<ACVMField[]> {
     await this.typedOracle.storeCapsule(
-      AztecAddress.fromField(fromACVMField(contractAddress)),
-      fromACVMField(slot),
-      capsule.map(fromACVMField),
+      AztecAddress.fromField(Fr.fromString(contractAddress)),
+      Fr.fromString(slot),
+      capsule.map(Fr.fromString),
     );
+    return [];
   }
 
   async loadCapsule(
@@ -427,23 +429,24 @@ export class Oracle {
     [tSize]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
     const values = await this.typedOracle.loadCapsule(
-      AztecAddress.fromField(fromACVMField(contractAddress)),
-      fromACVMField(slot),
+      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(frToNumber(fromACVMField(tSize))).fill(toACVMField(0))];
+      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)];
     }
   }
 
-  async deleteCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[]) {
-    await this.typedOracle.deleteCapsule(AztecAddress.fromField(fromACVMField(contractAddress)), fromACVMField(slot));
+  async deleteCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[]): Promise<ACVMField[]> {
+    await this.typedOracle.deleteCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot));
+    return [];
   }
 
   async copyCapsule(
@@ -451,13 +454,14 @@ export class Oracle {
     [srcSlot]: ACVMField[],
     [dstSlot]: ACVMField[],
     [numEntries]: ACVMField[],
-  ) {
+  ): Promise<ACVMField[]> {
     await this.typedOracle.copyCapsule(
-      AztecAddress.fromField(fromACVMField(contractAddress)),
-      fromACVMField(srcSlot),
-      fromACVMField(dstSlot),
-      frToNumber(fromACVMField(numEntries)),
+      AztecAddress.fromField(Fr.fromString(contractAddress)),
+      Fr.fromString(srcSlot),
+      Fr.fromString(dstSlot),
+      Fr.fromString(numEntries).toNumber(),
     );
+    return [];
   }
 
   async aes128Decrypt(
@@ -481,8 +485,8 @@ export class Oracle {
     [ephPKField2]: ACVMField[],
   ): Promise<ACVMField[]> {
     const secret = await this.typedOracle.getSharedSecret(
-      AztecAddress.fromField(fromACVMField(address)),
-      Point.fromFields([ephPKField0, ephPKField1, ephPKField2].map(fromACVMField)),
+      AztecAddress.fromField(Fr.fromString(address)),
+      Point.fromFields([ephPKField0, ephPKField1, ephPKField2].map(Fr.fromString)),
     );
     return secret.toFields().map(toACVMField);
   }

package/src/private/acvm/oracle/typed_oracle.ts

@@ -47,8 +47,8 @@ export abstract class TypedOracle {
     return Fr.random();
   }
 
-  storeInExecutionCache(_values: Fr[]): Promise<Fr> {
-    return Promise.reject(new OracleMethodNotAvailableError('storeInExecutionCache'));
+  storeInExecutionCache(_values: Fr[], _hash: Fr): void {
+    throw new OracleMethodNotAvailableError('storeInExecutionCache');
   }
 
   loadFromExecutionCache(_hash: Fr): Promise<Fr[]> {
@@ -87,8 +87,8 @@ export abstract class TypedOracle {
     return Promise.reject(new OracleMethodNotAvailableError('getNullifierMembershipWitness'));
   }
 
-  getPublicDataTreeWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    return Promise.reject(new OracleMethodNotAvailableError('getPublicDataTreeWitness'));
+  getPublicDataWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    return Promise.reject(new OracleMethodNotAvailableError('getPublicDataWitness'));
   }
 
   getLowNullifierMembershipWitness(
@@ -180,24 +180,22 @@ export abstract class TypedOracle {
     return Promise.reject(new OracleMethodNotAvailableError('callPrivateFunction'));
   }
 
-  enqueuePublicFunctionCall(
+  notifyEnqueuedPublicFunctionCall(
     _targetContractAddress: AztecAddress,
-    _functionSelector: FunctionSelector,
-    _argsHash: Fr,
+    _calldataHash: Fr,
     _sideEffectCounter: number,
     _isStaticCall: boolean,
-  ): Promise<Fr> {
-    return Promise.reject(new OracleMethodNotAvailableError('enqueuePublicFunctionCall'));
+  ): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('notifyEnqueuedPublicFunctionCall'));
   }
 
-  setPublicTeardownFunctionCall(
+  notifySetPublicTeardownFunctionCall(
     _targetContractAddress: AztecAddress,
-    _functionSelector: FunctionSelector,
-    _argsHash: Fr,
+    _calldataHash: Fr,
     _sideEffectCounter: number,
     _isStaticCall: boolean,
-  ): Promise<Fr> {
-    return Promise.reject(new OracleMethodNotAvailableError('setPublicTeardownFunctionCall'));
+  ): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('notifySetPublicTeardownFunctionCall'));
   }
 
   notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): void {

package/src/private/execution_data_provider.ts

@@ -1,5 +1,5 @@
 import type { Fr, Point } from '@aztec/foundation/fields';
-import type { FunctionArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { FunctionArtifact, FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
@@ -49,13 +49,6 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
    */
   getCompleteAddress(account: AztecAddress): Promise<CompleteAddress>;
 
-  /**
-   * Retrieve the auth witness for a given message hash.
-   * @param messageHash - The message hash.
-   * @returns A Promise that resolves to an array of field elements representing the auth witness.
-   */
-  getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
-
   /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.
@@ -90,7 +83,10 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
    * @param selector - The corresponding function selector.
    * @returns A Promise that resolves to a FunctionArtifact object.
    */
-  getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
+  getFunctionArtifact(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName>;
 
   /**
    * Generates a stable function name for debug purposes.
@@ -157,7 +153,7 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
    * @param blockNumber - The block number at which to get the witness.
    * @param leafSlot - The slot of the public data in the public data tree.
    */
-  getPublicDataTreeWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  getPublicDataWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
 
   /**
    * Gets the storage value at the given contract storage slot.