@aztec/simulator 0.80.0 → 0.82.0

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

@@ -1,12 +1,12 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr, Point } from '@aztec/foundation/fields';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 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 } from '../deserialize.js';
-import { toACVMField, toACVMFieldSingleOrArray } from '../serialize.js';
+import { fromBoundedVec, fromUintArray, fromUintBoundedVec } from '../deserialize.js';
+import { bufferToBoundedVec, toACVMField, toACVMFieldSingleOrArray } from '../serialize.js';
 import type { TypedOracle } from './typed_oracle.js';
 
 /**
@@ -15,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);
+  async storeInExecutionCache(_length: ACVMField[], values: ACVMField[]): Promise<ACVMField[]> {
+    const hash = await this.typedOracle.storeInExecutionCache(values.map(Fr.fromString));
+    return [toACVMField(hash)];
   }
 
-  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,
@@ -69,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) {
@@ -80,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) {
@@ -110,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) {
@@ -134,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(
@@ -166,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),
@@ -209,7 +212,7 @@ export class Oracle {
     }
 
     const paddedZeros = Array(returnFieldSize - returnData.length).fill(toACVMField(0));
-    return returnData.concat(paddedZeros);
+    return [returnData.concat(paddedZeros)];
   }
 
   notifyCreatedNote(
@@ -218,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(
@@ -266,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(
@@ -300,15 +309,15 @@ 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(
@@ -317,15 +326,15 @@ export class Oracle {
     [argsHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
-  ): Promise<ACVMField> {
+  ): Promise<ACVMField[]> {
     const newArgsHash = await this.typedOracle.enqueuePublicFunctionCall(
       AztecAddress.fromString(contractAddress),
-      FunctionSelector.fromField(fromACVMField(functionSelector)),
-      fromACVMField(argsHash),
-      frToNumber(fromACVMField(sideEffectCounter)),
-      frToBoolean(fromACVMField(isStaticCall)),
+      FunctionSelector.fromField(Fr.fromString(functionSelector)),
+      Fr.fromString(argsHash),
+      Fr.fromString(sideEffectCounter).toNumber(),
+      Fr.fromString(isStaticCall).toBool(),
     );
-    return toACVMField(newArgsHash);
+    return [toACVMField(newArgsHash)];
   }
 
   async setPublicTeardownFunctionCall(
@@ -334,38 +343,41 @@ export class Oracle {
     [argsHash]: ACVMField[],
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
-  ): Promise<ACVMField> {
+  ): Promise<ACVMField[]> {
     const newArgsHash = await this.typedOracle.setPublicTeardownFunctionCall(
       AztecAddress.fromString(contractAddress),
-      FunctionSelector.fromField(fromACVMField(functionSelector)),
-      fromACVMField(argsHash),
-      frToNumber(fromACVMField(sideEffectCounter)),
-      frToBoolean(fromACVMField(isStaticCall)),
+      FunctionSelector.fromField(Fr.fromString(functionSelector)),
+      Fr.fromString(argsHash),
+      Fr.fromString(sideEffectCounter).toNumber(),
+      Fr.fromString(isStaticCall).toBool(),
     );
-    return toACVMField(newArgsHash);
+    return [toACVMField(newArgsHash)];
   }
 
-  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(
@@ -378,26 +390,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)];
@@ -406,12 +418,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(
@@ -420,23 +433,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(
@@ -444,12 +458,40 @@ 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(
+    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);
+
+    const plaintext = await this.typedOracle.aes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
+    return bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
+  }
+
+  async getSharedSecret(
+    [address]: ACVMField[],
+    [ephPKField0]: ACVMField[],
+    [ephPKField1]: ACVMField[],
+    [ephPKField2]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const secret = await this.typedOracle.getSharedSecret(
+      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

@@ -1,5 +1,5 @@
 import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr, Point } from '@aztec/foundation/fields';
 import type { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
@@ -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(
@@ -256,4 +256,8 @@ export abstract class TypedOracle {
   aes128Decrypt(_ciphertext: Buffer, _iv: Buffer, _symKey: Buffer): Promise<Buffer> {
     return Promise.reject(new OracleMethodNotAvailableError('aes128Decrypt'));
   }
+
+  getSharedSecret(_address: AztecAddress, _ephPk: Point): Promise<Point> {
+    return Promise.reject(new OracleMethodNotAvailableError('getSharedSecret'));
+  }
 }

package/src/private/acvm/serialize.ts

@@ -58,3 +58,31 @@ export function toACVMWitness(witnessStartIndex: number, fields: Parameters<type
     return witness;
   }, new Map<number, ACVMField>());
 }
+
+export function bufferToU8Array(buffer: Buffer): ACVMField[] {
+  return Array.from(buffer).map(byte => toACVMField(BigInt(byte)));
+}
+
+export function bufferToBoundedVec(buffer: Buffer, maxLen: number): [ACVMField[], ACVMField] {
+  const u8Array = bufferToU8Array(buffer);
+  return arrayToBoundedVec(u8Array, maxLen);
+}
+
+/**
+ * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
+ * If the input array is shorter than the maxLen, it pads the result with zeros,
+ * so that nr can correctly coerce this result into a BoundedVec.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */
+export function arrayToBoundedVec(bVecStorage: ACVMField[], maxLen: number): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+  const lengthDiff = maxLen - bVecStorage.length;
+  const zeroPaddingArray = Array(lengthDiff).fill(toACVMField(BigInt(0)));
+  const storage = bVecStorage.concat(zeroPaddingArray);
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [storage, len];
+}