@aztec/pxe 1.2.1 → 2.0.0-nightly.20250813

package/dest/contract_function_simulator/oracle/oracle.js

@@ -4,6 +4,7 @@ import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { packAsRetrievedNote } from './note_packing_utils.js';
 /**
  * A data source that has all the apis required by Aztec.nr.
  */ export class Oracle {
@@ -12,59 +13,79 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
         this.typedOracle = typedOracle;
     }
     toACIRCallback() {
-        return Object.getOwnPropertyNames(Oracle.prototype).filter((name)=>name !== 'constructor' && name != 'toACIRCallback' && typeof this[name] === 'function').reduce((acc, name)=>{
-            acc[name] = this[name].bind(this);
+        const excludedProps = [
+            'typedOracle',
+            'constructor',
+            'toACIRCallback'
+        ];
+        // Get all the oracle function names
+        const oracleNames = Object.getOwnPropertyNames(Oracle.prototype).filter((name)=>!excludedProps.includes(name));
+        // Validate oracle names - these must be prefixed with either "private" or "utility" to indicate their scope
+        // and must correspond to a function on the Oracle class.
+        oracleNames.forEach((name)=>{
+            if (!name.startsWith('private') && !name.startsWith('utility')) {
+                throw new Error(`Oracle function "${name}" must be prefixed with either "private" or "utility" to indicate its scope`);
+            }
+            const method = this[name];
+            if (typeof method !== 'function') {
+                throw new Error(`Oracle property "${name}" must be a function`);
+            }
+        });
+        // Build callback object and return it
+        return oracleNames.reduce((acc, name)=>{
+            const method = this[name];
+            acc[name] = method.bind(this);
             return acc;
         }, {});
     }
-    getRandomField() {
-        const val = this.typedOracle.getRandomField();
+    utilityGetRandomField() {
+        const val = this.typedOracle.utilityGetRandomField();
         return Promise.resolve([
             toACVMField(val)
         ]);
     }
     // Since the argument is a slice, noir automatically adds a length field to oracle call.
-    storeInExecutionCache(_length, values, [hash]) {
-        this.typedOracle.storeInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
+    privateStoreInExecutionCache(_length, values, [hash]) {
+        this.typedOracle.privateStoreInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
         return Promise.resolve([]);
     }
-    async loadFromExecutionCache([returnsHash]) {
-        const values = await this.typedOracle.loadFromExecutionCache(Fr.fromString(returnsHash));
+    async privateLoadFromExecutionCache([returnsHash]) {
+        const values = await this.typedOracle.privateLoadFromExecutionCache(Fr.fromString(returnsHash));
         return [
             values.map(toACVMField)
         ];
     }
-    async getBlockNumber() {
+    async utilityGetBlockNumber() {
         return [
-            toACVMField(await this.typedOracle.getBlockNumber())
+            toACVMField(await this.typedOracle.utilityGetBlockNumber())
         ];
     }
-    async getTimestamp() {
+    async utilityGetTimestamp() {
         return [
-            toACVMField(await this.typedOracle.getTimestamp())
+            toACVMField(await this.typedOracle.utilityGetTimestamp())
         ];
     }
-    async getContractAddress() {
+    async utilityGetContractAddress() {
         return [
-            toACVMField(await this.typedOracle.getContractAddress())
+            toACVMField(await this.typedOracle.utilityGetContractAddress())
         ];
     }
-    async getVersion() {
+    async utilityGetVersion() {
         return [
-            toACVMField(await this.typedOracle.getVersion())
+            toACVMField(await this.typedOracle.utilityGetVersion())
         ];
     }
-    async getChainId() {
+    async utilityGetChainId() {
         return [
-            toACVMField(await this.typedOracle.getChainId())
+            toACVMField(await this.typedOracle.utilityGetChainId())
         ];
     }
-    async getKeyValidationRequest([pkMHash]) {
-        const keyValidationRequest = await this.typedOracle.getKeyValidationRequest(Fr.fromString(pkMHash));
+    async utilityGetKeyValidationRequest([pkMHash]) {
+        const keyValidationRequest = await this.typedOracle.utilityGetKeyValidationRequest(Fr.fromString(pkMHash));
         return keyValidationRequest.toFields().map(toACVMField);
     }
-    async getContractInstance([address]) {
-        const instance = await this.typedOracle.getContractInstance(AztecAddress.fromField(Fr.fromString(address)));
+    async utilityGetContractInstance([address]) {
+        const instance = await this.typedOracle.utilityGetContractInstance(AztecAddress.fromField(Fr.fromString(address)));
         return [
             instance.salt,
             instance.deployer,
@@ -73,11 +94,11 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
             ...instance.publicKeys.toFields()
         ].map(toACVMField);
     }
-    async getMembershipWitness([blockNumber], [treeId], [leafValue]) {
+    async utilityGetMembershipWitness([blockNumber], [treeId], [leafValue]) {
         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);
+        const witness = await this.typedOracle.utilityGetMembershipWitness(parsedBlockNumber, parsedTreeId, parsedLeafValue);
         if (!witness) {
             throw new Error(`Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block ${parsedBlockNumber}.`);
         }
@@ -86,44 +107,44 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
             witness.slice(1).map(toACVMField)
         ];
     }
-    async getNullifierMembershipWitness([blockNumber], [nullifier]) {
+    async utilityGetNullifierMembershipWitness([blockNumber], [nullifier]) {
         const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
         const parsedNullifier = Fr.fromString(nullifier);
-        const witness = await this.typedOracle.getNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
+        const witness = await this.typedOracle.utilityGetNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
         if (!witness) {
             throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
         }
         return witness.toNoirRepresentation();
     }
-    async getLowNullifierMembershipWitness([blockNumber], [nullifier]) {
+    async utilityGetLowNullifierMembershipWitness([blockNumber], [nullifier]) {
         const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
         const parsedNullifier = Fr.fromString(nullifier);
-        const witness = await this.typedOracle.getLowNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
+        const witness = await this.typedOracle.utilityGetLowNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
         if (!witness) {
             throw new Error(`Low nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
         }
         return witness.toNoirRepresentation();
     }
-    async getPublicDataWitness([blockNumber], [leafSlot]) {
+    async utilityGetPublicDataWitness([blockNumber], [leafSlot]) {
         const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
         const parsedLeafSlot = Fr.fromString(leafSlot);
-        const witness = await this.typedOracle.getPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
+        const witness = await this.typedOracle.utilityGetPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
         if (!witness) {
             throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
         }
         return witness.toNoirRepresentation();
     }
-    async getBlockHeader([blockNumber]) {
+    async utilityGetBlockHeader([blockNumber]) {
         const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
-        const header = await this.typedOracle.getBlockHeader(parsedBlockNumber);
+        const header = await this.typedOracle.utilityGetBlockHeader(parsedBlockNumber);
         if (!header) {
             throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
         }
         return header.toFields().map(toACVMField);
     }
-    async getAuthWitness([messageHash]) {
+    async utilityGetAuthWitness([messageHash]) {
         const messageHashField = Fr.fromString(messageHash);
-        const witness = await this.typedOracle.getAuthWitness(messageHashField);
+        const witness = await this.typedOracle.utilityGetAuthWitness(messageHashField);
         if (!witness) {
             throw new Error(`Unknown auth witness for message hash ${messageHashField}`);
         }
@@ -131,9 +152,10 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
             witness.map(toACVMField)
         ];
     }
-    async getPublicKeysAndPartialAddress([address]) {
+    // TODO(benesjan): This doesn't map to the underlying oracle name which is just ugly.
+    async utilityGetPublicKeysAndPartialAddress([address]) {
         const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
-        const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
+        const { publicKeys, partialAddress } = await this.typedOracle.utilityGetCompleteAddress(parsedAddress);
         return [
             [
                 ...publicKeys.toFields(),
@@ -141,80 +163,64 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
             ].map(toACVMField)
         ];
     }
-    async getNotes([storageSlot], [numSelects], selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, [limit], [offset], [status], [maxNotes], [packedRetrievedNoteLength]) {
-        const noteDatas = await this.typedOracle.getNotes(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);
+    async utilityGetNotes([storageSlot], [numSelects], selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, [limit], [offset], [status], [maxNotes], [packedRetrievedNoteLength]) {
+        const noteDatas = await this.typedOracle.utilityGetNotes(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);
         if (noteDatas.length > 0) {
             const noteLength = noteDatas[0].note.items.length;
             if (!noteDatas.every(({ note })=>noteLength === note.items.length)) {
                 throw new Error('Notes should all be the same length.');
             }
         }
-        // The expected return type is a BoundedVec<[Field; packedRetrievedNoteLength], maxNotes> where each
-        // array is structured as [contract_address, note_nonce, nonzero_note_hash_counter, ...packed_note].
-        const returnDataAsArrayOfArrays = noteDatas.map(({ contractAddress, noteNonce, index, note })=>{
-            // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
-            const noteIsTransient = index === undefined;
-            const nonzeroNoteHashCounter = noteIsTransient ? true : false;
-            // If you change the array on the next line you have to change the `unpack_retrieved_note` function in
-            // `aztec/src/note/retrieved_note.nr`
-            return [
-                contractAddress,
-                noteNonce,
-                nonzeroNoteHashCounter,
-                ...note.items
-            ];
-        });
+        const returnDataAsArrayOfPackedRetrievedNotes = noteDatas.map(packAsRetrievedNote);
         // Now we convert each sub-array to an array of ACVMField
-        const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfArrays.map((subArray)=>subArray.map(toACVMField));
+        const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedRetrievedNotes.map((subArray)=>subArray.map(toACVMField));
         // At last we convert the array of arrays to a bounded vec of arrays
         return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedRetrievedNoteLength);
     }
-    notifyCreatedNote([storageSlot], [noteTypeId], note, [noteHash], [counter]) {
-        this.typedOracle.notifyCreatedNote(Fr.fromString(storageSlot), NoteSelector.fromField(Fr.fromString(noteTypeId)), note.map(Fr.fromString), Fr.fromString(noteHash), +counter);
+    privateNotifyCreatedNote([storageSlot], [noteTypeId], note, [noteHash], [counter]) {
+        this.typedOracle.privateNotifyCreatedNote(Fr.fromString(storageSlot), NoteSelector.fromField(Fr.fromString(noteTypeId)), note.map(Fr.fromString), Fr.fromString(noteHash), +counter);
         return Promise.resolve([]);
     }
-    async notifyNullifiedNote([innerNullifier], [noteHash], [counter]) {
-        await this.typedOracle.notifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
+    async privateNotifyNullifiedNote([innerNullifier], [noteHash], [counter]) {
+        await this.typedOracle.privateNotifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
         return [];
     }
-    async notifyCreatedNullifier([innerNullifier]) {
-        await this.typedOracle.notifyCreatedNullifier(Fr.fromString(innerNullifier));
+    async privateNotifyCreatedNullifier([innerNullifier]) {
+        await this.typedOracle.privateNotifyCreatedNullifier(Fr.fromString(innerNullifier));
         return [];
     }
-    async checkNullifierExists([innerNullifier]) {
-        const exists = await this.typedOracle.checkNullifierExists(Fr.fromString(innerNullifier));
+    async utilityCheckNullifierExists([innerNullifier]) {
+        const exists = await this.typedOracle.utilityCheckNullifierExists(Fr.fromString(innerNullifier));
         return [
             toACVMField(exists)
         ];
     }
-    async getL1ToL2MembershipWitness([contractAddress], [messageHash], [secret]) {
-        const message = await this.typedOracle.getL1ToL2MembershipWitness(AztecAddress.fromString(contractAddress), Fr.fromString(messageHash), Fr.fromString(secret));
+    async utilityGetL1ToL2MembershipWitness([contractAddress], [messageHash], [secret]) {
+        const message = await this.typedOracle.utilityGetL1ToL2MembershipWitness(AztecAddress.fromString(contractAddress), Fr.fromString(messageHash), Fr.fromString(secret));
         return message.toNoirRepresentation();
     }
-    async storageRead([contractAddress], [startStorageSlot], [blockNumber], [numberOfElements]) {
-        const values = await this.typedOracle.storageRead(new AztecAddress(Fr.fromString(contractAddress)), Fr.fromString(startStorageSlot), +blockNumber, +numberOfElements);
+    async utilityStorageRead([contractAddress], [startStorageSlot], [blockNumber], [numberOfElements]) {
+        const values = await this.typedOracle.utilityStorageRead(new AztecAddress(Fr.fromString(contractAddress)), Fr.fromString(startStorageSlot), +blockNumber, +numberOfElements);
         return [
             values.map(toACVMField)
         ];
     }
-    async storageWrite([startStorageSlot], values) {
-        const newValues = await this.typedOracle.storageWrite(Fr.fromString(startStorageSlot), values.map(Fr.fromString));
-        return newValues.map(toACVMField);
-    }
-    notifyCreatedContractClassLog([contractAddress], message, [length], [counter]) {
+    privateNotifyCreatedContractClassLog([contractAddress], message, [length], [counter]) {
         const logFields = new ContractClassLogFields(message.map(Fr.fromString));
         const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
-        this.typedOracle.notifyCreatedContractClassLog(log, +counter);
+        this.typedOracle.privateNotifyCreatedContractClassLog(log, +counter);
         return Promise.resolve([]);
     }
-    debugLog(message, _ignoredFieldsSize, fields) {
+    utilityDebugLog(message, _ignoredFieldsSize, fields) {
         const messageStr = message.map((acvmField)=>String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
         const fieldsFr = fields.map(Fr.fromString);
-        this.typedOracle.debugLog(messageStr, fieldsFr);
+        this.typedOracle.utilityDebugLog(messageStr, fieldsFr);
         return Promise.resolve([]);
     }
-    async callPrivateFunction([contractAddress], [functionSelector], [argsHash], [sideEffectCounter], [isStaticCall]) {
-        const { endSideEffectCounter, returnsHash } = await this.typedOracle.callPrivateFunction(AztecAddress.fromField(Fr.fromString(contractAddress)), FunctionSelector.fromField(Fr.fromString(functionSelector)), Fr.fromString(argsHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
+    // This function's name is directly hardcoded in `circuit_recorder.ts`. Don't forget to update it there if you
+    // change the name here.
+    async privateCallPrivateFunction([contractAddress], [functionSelector], [argsHash], [sideEffectCounter], [isStaticCall]) {
+        const { endSideEffectCounter, returnsHash } = await this.typedOracle.privateCallPrivateFunction(AztecAddress.fromField(Fr.fromString(contractAddress)), FunctionSelector.fromField(Fr.fromString(functionSelector)), Fr.fromString(argsHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
         return [
             [
                 endSideEffectCounter,
@@ -222,44 +228,44 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
             ].map(toACVMField)
         ];
     }
-    async notifyEnqueuedPublicFunctionCall([contractAddress], [calldataHash], [sideEffectCounter], [isStaticCall]) {
-        await this.typedOracle.notifyEnqueuedPublicFunctionCall(AztecAddress.fromString(contractAddress), Fr.fromString(calldataHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
+    async privateNotifyEnqueuedPublicFunctionCall([contractAddress], [calldataHash], [sideEffectCounter], [isStaticCall]) {
+        await this.typedOracle.privateNotifyEnqueuedPublicFunctionCall(AztecAddress.fromString(contractAddress), Fr.fromString(calldataHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
         return [];
     }
-    async notifySetPublicTeardownFunctionCall([contractAddress], [calldataHash], [sideEffectCounter], [isStaticCall]) {
-        await this.typedOracle.notifySetPublicTeardownFunctionCall(AztecAddress.fromString(contractAddress), Fr.fromString(calldataHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
+    async privateNotifySetPublicTeardownFunctionCall([contractAddress], [calldataHash], [sideEffectCounter], [isStaticCall]) {
+        await this.typedOracle.privateNotifySetPublicTeardownFunctionCall(AztecAddress.fromString(contractAddress), Fr.fromString(calldataHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
         return [];
     }
-    async notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]) {
-        await this.typedOracle.notifySetMinRevertibleSideEffectCounter(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
+    async privateNotifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]) {
+        await this.typedOracle.privateNotifySetMinRevertibleSideEffectCounter(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
         return Promise.resolve([]);
     }
-    async getIndexedTaggingSecretAsSender([sender], [recipient]) {
-        const taggingSecret = await this.typedOracle.getIndexedTaggingSecretAsSender(AztecAddress.fromString(sender), AztecAddress.fromString(recipient));
+    async utilityGetIndexedTaggingSecretAsSender([sender], [recipient]) {
+        const taggingSecret = await this.typedOracle.utilityGetIndexedTaggingSecretAsSender(AztecAddress.fromString(sender), AztecAddress.fromString(recipient));
         return taggingSecret.toFields().map(toACVMField);
     }
-    async incrementAppTaggingSecretIndexAsSender([sender], [recipient]) {
-        await this.typedOracle.incrementAppTaggingSecretIndexAsSender(AztecAddress.fromString(sender), AztecAddress.fromString(recipient));
+    async privateIncrementAppTaggingSecretIndexAsSender([sender], [recipient]) {
+        await this.typedOracle.privateIncrementAppTaggingSecretIndexAsSender(AztecAddress.fromString(sender), AztecAddress.fromString(recipient));
         return [];
     }
-    async fetchTaggedLogs([pendingTaggedLogArrayBaseSlot]) {
-        await this.typedOracle.fetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
+    async utilityFetchTaggedLogs([pendingTaggedLogArrayBaseSlot]) {
+        await this.typedOracle.utilityFetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
         return [];
     }
-    async validateEnqueuedNotesAndEvents([contractAddress], [noteValidationRequestsArrayBaseSlot], [eventValidationRequestsArrayBaseSlot]) {
-        await this.typedOracle.validateEnqueuedNotesAndEvents(AztecAddress.fromString(contractAddress), Fr.fromString(noteValidationRequestsArrayBaseSlot), Fr.fromString(eventValidationRequestsArrayBaseSlot));
+    async utilityValidateEnqueuedNotesAndEvents([contractAddress], [noteValidationRequestsArrayBaseSlot], [eventValidationRequestsArrayBaseSlot]) {
+        await this.typedOracle.utilityValidateEnqueuedNotesAndEvents(AztecAddress.fromString(contractAddress), Fr.fromString(noteValidationRequestsArrayBaseSlot), Fr.fromString(eventValidationRequestsArrayBaseSlot));
         return [];
     }
-    async bulkRetrieveLogs([contractAddress], [logRetrievalRequestsArrayBaseSlot], [logRetrievalResponsesArrayBaseSlot]) {
-        await this.typedOracle.bulkRetrieveLogs(AztecAddress.fromString(contractAddress), Fr.fromString(logRetrievalRequestsArrayBaseSlot), Fr.fromString(logRetrievalResponsesArrayBaseSlot));
+    async utilityBulkRetrieveLogs([contractAddress], [logRetrievalRequestsArrayBaseSlot], [logRetrievalResponsesArrayBaseSlot]) {
+        await this.typedOracle.utilityBulkRetrieveLogs(AztecAddress.fromString(contractAddress), Fr.fromString(logRetrievalRequestsArrayBaseSlot), Fr.fromString(logRetrievalResponsesArrayBaseSlot));
         return [];
     }
-    async storeCapsule([contractAddress], [slot], capsule) {
-        await this.typedOracle.storeCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot), capsule.map(Fr.fromString));
+    async utilityStoreCapsule([contractAddress], [slot], capsule) {
+        await this.typedOracle.utilityStoreCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot), capsule.map(Fr.fromString));
         return [];
     }
-    async loadCapsule([contractAddress], [slot], [tSize]) {
-        const values = await this.typedOracle.loadCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot));
+    async utilityLoadCapsule([contractAddress], [slot], [tSize]) {
+        const values = await this.typedOracle.utilityLoadCapsule(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) {
@@ -276,31 +282,46 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
             ];
         }
     }
-    async deleteCapsule([contractAddress], [slot]) {
-        await this.typedOracle.deleteCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot));
+    async utilityDeleteCapsule([contractAddress], [slot]) {
+        await this.typedOracle.utilityDeleteCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot));
         return [];
     }
-    async copyCapsule([contractAddress], [srcSlot], [dstSlot], [numEntries]) {
-        await this.typedOracle.copyCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(srcSlot), Fr.fromString(dstSlot), Fr.fromString(numEntries).toNumber());
+    async utilityCopyCapsule([contractAddress], [srcSlot], [dstSlot], [numEntries]) {
+        await this.typedOracle.utilityCopyCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(srcSlot), Fr.fromString(dstSlot), Fr.fromString(numEntries).toNumber());
         return [];
     }
-    async aes128Decrypt(ciphertextBVecStorage, [ciphertextLength], iv, symKey) {
+    async utilityAes128Decrypt(ciphertextBVecStorage, [ciphertextLength], iv, symKey) {
         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);
+        const plaintext = await this.typedOracle.utilityAes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
         return bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
     }
-    async getSharedSecret([address], [ephPKField0], [ephPKField1], [ephPKField2]) {
-        const secret = await this.typedOracle.getSharedSecret(AztecAddress.fromField(Fr.fromString(address)), Point.fromFields([
+    async utilityGetSharedSecret([address], [ephPKField0], [ephPKField1], [ephPKField2]) {
+        const secret = await this.typedOracle.utilityGetSharedSecret(AztecAddress.fromField(Fr.fromString(address)), Point.fromFields([
             ephPKField0,
             ephPKField1,
             ephPKField2
         ].map(Fr.fromString)));
         return secret.toFields().map(toACVMField);
     }
-    async emitOffchainEffect(data) {
-        await this.typedOracle.emitOffchainEffect(data.map(Fr.fromString));
+    async utilityEmitOffchainEffect(data) {
+        await this.typedOracle.utilityEmitOffchainEffect(data.map(Fr.fromString));
+        return [];
+    }
+    async privateGetSenderForTags() {
+        const sender = await this.typedOracle.privateGetSenderForTags();
+        // Return [1, address] for Some(address), [0, 0] for None
+        return sender ? [
+            toACVMField(1n),
+            toACVMField(sender)
+        ] : [
+            toACVMField(0n),
+            toACVMField(0n)
+        ];
+    }
+    async privateSetSenderForTags([senderForTags]) {
+        await this.typedOracle.privateSetSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
         return [];
     }
 }

package/dest/contract_function_simulator/oracle/private_execution.d.ts

@@ -11,6 +11,11 @@ import type { ExecutionDataProvider } from '../execution_data_provider.js';
 import type { PrivateExecutionOracle } from './private_execution_oracle.js';
 /**
  * Execute a private function and return the execution result.
+ * This does not execute any kernel circuits; only the user functions.
+ *
+ * If this private function execution results in any nested private function calls,
+ * those nested calls are made via oracle calls to the `privateCallPrivateFunction` oracle,
+ * which in turn makes corresponding further calls to this function.
  */
 export declare function executePrivateFunction(simulator: CircuitSimulator, privateExecutionOracle: PrivateExecutionOracle, artifact: FunctionArtifactWithContractName, contractAddress: AztecAddress, functionSelector: FunctionSelector, log?: import("@aztec/foundation/log").Logger): Promise<PrivateCallExecutionResult>;
 /**
@@ -26,8 +31,8 @@ export declare function extractPrivateCircuitPublicInputs(artifact: FunctionArti
  * @param contractAddress - The address of the contract to read the class id for.
  * @param instance - The instance of the contract.
  * @param executionDataProvider - The execution data provider.
- * @param blockNumber - The block number at which to load the SharedMutable storing the class id.
- * @param timestamp - The timestamp at which to obtain the class id from the SharedMutable.
+ * @param blockNumber - The block number at which to load the DelayedPublicMutable storing the class id.
+ * @param timestamp - The timestamp at which to obtain the class id from the DelayedPublicMutable.
  * @returns The current class id.
  */
 export declare function readCurrentClassId(contractAddress: AztecAddress, instance: ContractInstance, executionDataProvider: ExecutionDataProvider | AztecNode, blockNumber: number, timestamp: UInt64): Promise<Fr>;

package/dest/contract_function_simulator/oracle/private_execution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private_execution.d.ts","sourceRoot":"","sources":["../../../src/contract_function_simulator/oracle/private_execution.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAKtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gCAAgC,EACrC,KAAK,gBAAgB,EAEtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAGlE,OAAO,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,gBAAgB,EAC3B,sBAAsB,EAAE,sBAAsB,EAC9C,QAAQ,EAAE,gCAAgC,EAC1C,eAAe,EAAE,YAAY,EAC7B,gBAAgB,EAAE,gBAAgB,EAClC,GAAG,yCAA8C,GAChD,OAAO,CAAC,0BAA0B,CAAC,CA2ErC;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,gBAAgB,EAC1B,cAAc,EAAE,WAAW,GAC1B,0BAA0B,CAa5B;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,qBAAqB,EAAE,qBAAqB,GAAG,SAAS,EACxD,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,eAWlB;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,YAAY,EAC7B,qBAAqB,EAAE,qBAAqB,EAC5C,MAAM,CAAC,EAAE,WAAW,iBA2BrB"}
+{"version":3,"file":"private_execution.d.ts","sourceRoot":"","sources":["../../../src/contract_function_simulator/oracle/private_execution.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAKtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gCAAgC,EACrC,KAAK,gBAAgB,EAEtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE,OAAO,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,gBAAgB,EAC3B,sBAAsB,EAAE,sBAAsB,EAC9C,QAAQ,EAAE,gCAAgC,EAC1C,eAAe,EAAE,YAAY,EAC7B,gBAAgB,EAAE,gBAAgB,EAClC,GAAG,yCAA8C,GAChD,OAAO,CAAC,0BAA0B,CAAC,CA2ErC;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,gBAAgB,EAC1B,cAAc,EAAE,WAAW,GAC1B,0BAA0B,CAa5B;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,qBAAqB,EAAE,qBAAqB,GAAG,SAAS,EACxD,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,eAWlB;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,YAAY,EAC7B,qBAAqB,EAAE,qBAAqB,EAC5C,MAAM,CAAC,EAAE,WAAW,iBA2BrB"}

package/dest/contract_function_simulator/oracle/private_execution.js

@@ -5,12 +5,17 @@ import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ExecutionError, extractCallStack, resolveAssertionMessageFromError, witnessMapToFields } from '@aztec/simulator/client';
 import { countArgumentsSize } from '@aztec/stdlib/abi';
+import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
-import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
 import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
 import { Oracle } from './oracle.js';
 /**
  * Execute a private function and return the execution result.
+ * This does not execute any kernel circuits; only the user functions.
+ *
+ * If this private function execution results in any nested private function calls,
+ * those nested calls are made via oracle calls to the `privateCallPrivateFunction` oracle,
+ * which in turn makes corresponding further calls to this function.
  */ export async function executePrivateFunction(simulator, privateExecutionOracle, artifact, contractAddress, functionSelector, log = createLogger('simulator:private_execution')) {
     const functionName = await privateExecutionOracle.getDebugFunctionName();
     log.verbose(`Executing private function ${functionName}`, {
@@ -42,21 +47,21 @@ import { Oracle } from './oracle.js';
         appCircuitName: functionName
     });
     const contractClassLogs = privateExecutionOracle.getContractClassLogs();
-    const rawReturnValues = await privateExecutionOracle.loadFromExecutionCache(publicInputs.returnsHash);
+    const rawReturnValues = await privateExecutionOracle.privateLoadFromExecutionCache(publicInputs.returnsHash);
     const noteHashLeafIndexMap = privateExecutionOracle.getNoteHashLeafIndexMap();
     const newNotes = privateExecutionOracle.getNewNotes();
     const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
     const offchainEffects = privateExecutionOracle.getOffchainEffects();
-    const nestedExecutions = privateExecutionOracle.getNestedExecutions();
-    let timerSubtractionList = nestedExecutions;
+    const nestedExecutionResults = privateExecutionOracle.getNestedExecutionResults();
+    let timerSubtractionList = nestedExecutionResults;
     let witgenTime = duration;
     // Due to the recursive nature of execution, we have to subtract the time taken by nested calls
     while(timerSubtractionList.length > 0){
         witgenTime -= timerSubtractionList.reduce((acc, nested)=>acc + (nested.profileResult?.timings.witgen ?? 0), 0);
-        timerSubtractionList = timerSubtractionList.flatMap((nested)=>nested.nestedExecutions ?? []);
+        timerSubtractionList = timerSubtractionList.flatMap((nested)=>nested.nestedExecutionResults ?? []);
     }
     log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
-    return new PrivateCallExecutionResult(artifact.bytecode, Buffer.from(artifact.verificationKey, 'base64'), partialWitness, publicInputs, noteHashLeafIndexMap, newNotes, noteHashNullifierCounterMap, rawReturnValues, offchainEffects, nestedExecutions, contractClassLogs, {
+    return new PrivateCallExecutionResult(artifact.bytecode, Buffer.from(artifact.verificationKey, 'base64'), partialWitness, publicInputs, noteHashLeafIndexMap, newNotes, noteHashNullifierCounterMap, rawReturnValues, offchainEffects, nestedExecutionResults, contractClassLogs, {
         timings: {
             witgen: witgenTime,
             oracles: acirExecutionResult.oracles
@@ -88,13 +93,13 @@ import { Oracle } from './oracle.js';
  * @param contractAddress - The address of the contract to read the class id for.
  * @param instance - The instance of the contract.
  * @param executionDataProvider - The execution data provider.
- * @param blockNumber - The block number at which to load the SharedMutable storing the class id.
- * @param timestamp - The timestamp at which to obtain the class id from the SharedMutable.
+ * @param blockNumber - The block number at which to load the DelayedPublicMutable storing the class id.
+ * @param timestamp - The timestamp at which to obtain the class id from the DelayedPublicMutable.
  * @returns The current class id.
  */ export async function readCurrentClassId(contractAddress, instance, executionDataProvider, blockNumber, timestamp) {
-    const { sharedMutableSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-    const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, (slot)=>executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceDeployer, slot));
-    let currentClassId = sharedMutableValues.svc.getCurrentAt(timestamp)[0];
+    const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
+    const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, (slot)=>executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceRegistry, slot));
+    let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
     if (currentClassId.isZero()) {
         currentClassId = instance.originalContractClassId;
     }