@aztec/pxe 0.87.4 → 0.87.6

package/dest/contract_function_simulator/oracle/oracle.js

@@ -0,0 +1,317 @@
+import { Fr, Point } from '@aztec/foundation/fields';
+import { arrayOfArraysToBoundedVecOfArrays, bufferToBoundedVec, fromBoundedVec, fromUintArray, fromUintBoundedVec, toACVMField, toACVMFieldSingleOrArray } from '@aztec/simulator/client';
+import { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ContractClassLog, ContractClassLogFields, LogWithTxData } from '@aztec/stdlib/logs';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { TxHash } from '@aztec/stdlib/tx';
+/**
+ * A data source that has all the apis required by Aztec.nr.
+ */ export class Oracle {
+    typedOracle;
+    constructor(typedOracle){
+        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);
+            return acc;
+        }, {});
+    }
+    getRandomField() {
+        const val = this.typedOracle.getRandomField();
+        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));
+        return Promise.resolve([]);
+    }
+    async loadFromExecutionCache([returnsHash]) {
+        const values = await this.typedOracle.loadFromExecutionCache(Fr.fromString(returnsHash));
+        return [
+            values.map(toACVMField)
+        ];
+    }
+    async getBlockNumber() {
+        return [
+            toACVMField(await this.typedOracle.getBlockNumber())
+        ];
+    }
+    async getContractAddress() {
+        return [
+            toACVMField(await this.typedOracle.getContractAddress())
+        ];
+    }
+    async getVersion() {
+        return [
+            toACVMField(await this.typedOracle.getVersion())
+        ];
+    }
+    async getChainId() {
+        return [
+            toACVMField(await this.typedOracle.getChainId())
+        ];
+    }
+    async getKeyValidationRequest([pkMHash]) {
+        const keyValidationRequest = await this.typedOracle.getKeyValidationRequest(Fr.fromString(pkMHash));
+        return keyValidationRequest.toFields().map(toACVMField);
+    }
+    async getContractInstance([address]) {
+        const instance = await this.typedOracle.getContractInstance(AztecAddress.fromField(Fr.fromString(address)));
+        return [
+            instance.salt,
+            instance.deployer,
+            instance.currentContractClassId,
+            instance.initializationHash,
+            ...instance.publicKeys.toFields()
+        ].map(toACVMField);
+    }
+    async getMembershipWitness([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);
+        if (!witness) {
+            throw new Error(`Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block ${parsedBlockNumber}.`);
+        }
+        return [
+            toACVMField(witness[0]),
+            witness.slice(1).map(toACVMField)
+        ];
+    }
+    async getNullifierMembershipWitness([blockNumber], [nullifier]) {
+        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.toNoirRepresentation();
+    }
+    async getLowNullifierMembershipWitness([blockNumber], [nullifier]) {
+        const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+        const parsedNullifier = Fr.fromString(nullifier);
+        const witness = await this.typedOracle.getLowNullifierMembershipWitness(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]) {
+        const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+        const parsedLeafSlot = Fr.fromString(leafSlot);
+        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.toNoirRepresentation();
+    }
+    async getBlockHeader([blockNumber]) {
+        const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+        const header = await this.typedOracle.getBlockHeader(parsedBlockNumber);
+        if (!header) {
+            throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
+        }
+        return header.toFields().map(toACVMField);
+    }
+    async getAuthWitness([messageHash]) {
+        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)
+        ];
+    }
+    async getPublicKeysAndPartialAddress([address]) {
+        const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
+        const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
+        return [
+            [
+                ...publicKeys.toFields(),
+                partialAddress
+            ].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);
+        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, nonce, nonzero_note_hash_counter, ...packed_note].
+        const returnDataAsArrayOfArrays = noteDatas.map(({ contractAddress, nonce, 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,
+                nonce,
+                nonzeroNoteHashCounter,
+                ...note.items
+            ];
+        });
+        // Now we convert each sub-array to an array of ACVMField
+        const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfArrays.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);
+        return Promise.resolve([]);
+    }
+    async notifyNullifiedNote([innerNullifier], [noteHash], [counter]) {
+        await this.typedOracle.notifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
+        return [];
+    }
+    async notifyCreatedNullifier([innerNullifier]) {
+        await this.typedOracle.notifyCreatedNullifier(Fr.fromString(innerNullifier));
+        return [];
+    }
+    async checkNullifierExists([innerNullifier]) {
+        const exists = await this.typedOracle.checkNullifierExists(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));
+        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);
+        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]) {
+        const logFields = new ContractClassLogFields(message.map(Fr.fromString));
+        const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
+        this.typedOracle.notifyCreatedContractClassLog(log, +counter);
+        return Promise.resolve([]);
+    }
+    debugLog(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);
+        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());
+        return [
+            [
+                endSideEffectCounter,
+                returnsHash
+            ].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());
+        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());
+        return [];
+    }
+    async notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]) {
+        await this.typedOracle.notifySetMinRevertibleSideEffectCounter(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
+        return Promise.resolve([]);
+    }
+    async getIndexedTaggingSecretAsSender([sender], [recipient]) {
+        const taggingSecret = await this.typedOracle.getIndexedTaggingSecretAsSender(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));
+        return [];
+    }
+    async fetchTaggedLogs([pendingTaggedLogArrayBaseSlot]) {
+        await this.typedOracle.fetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
+        return [];
+    }
+    async deliverNote([contractAddress], [storageSlot], [nonce], content, [contentLength], [noteHash], [nullifier], [txHash], [recipient]) {
+        // 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), Fr.fromString(storageSlot), Fr.fromString(nonce), fromBoundedVec(content, contentLength), Fr.fromString(noteHash), Fr.fromString(nullifier), TxHash.fromString(txHash), AztecAddress.fromString(recipient));
+        return [
+            toACVMField(true)
+        ];
+    }
+    async getLogByTag([tag]) {
+        const log = await this.typedOracle.getLogByTag(Fr.fromString(tag));
+        if (log == null) {
+            return [
+                toACVMField(0),
+                ...LogWithTxData.noirSerializationOfEmpty().map(toACVMFieldSingleOrArray)
+            ];
+        } else {
+            return [
+                toACVMField(1),
+                ...log.toNoirSerialization().map(toACVMFieldSingleOrArray)
+            ];
+        }
+    }
+    async storeCapsule([contractAddress], [slot], capsule) {
+        await this.typedOracle.storeCapsule(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));
+        // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
+        // with two fields: `some` (a boolean) and `value` (a field array in this case).
+        if (values === null) {
+            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
+            return [
+                toACVMField(0),
+                Array(Fr.fromString(tSize).toNumber()).fill(toACVMField(0))
+            ];
+        } else {
+            // Data was found so we set `some` to 1 and return it along with `value`.
+            return [
+                toACVMField(1),
+                values.map(toACVMField)
+            ];
+        }
+    }
+    async deleteCapsule([contractAddress], [slot]) {
+        await this.typedOracle.deleteCapsule(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());
+        return [];
+    }
+    async aes128Decrypt(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);
+        return bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
+    }
+    async getSharedSecret([address], [ephPKField0], [ephPKField1], [ephPKField2]) {
+        const secret = await this.typedOracle.getSharedSecret(AztecAddress.fromField(Fr.fromString(address)), Point.fromFields([
+            ephPKField0,
+            ephPKField1,
+            ephPKField2
+        ].map(Fr.fromString)));
+        return secret.toFields().map(toACVMField);
+    }
+    async storePrivateEventLog([contractAddress], [recipient], [eventSelector], msgContentBVecStorage, [msgContentLength], [txHash], [logIndexInTx], [txIndexInBlock]) {
+        await this.typedOracle.storePrivateEventLog(AztecAddress.fromField(Fr.fromString(contractAddress)), AztecAddress.fromField(Fr.fromString(recipient)), EventSelector.fromField(Fr.fromString(eventSelector)), fromBoundedVec(msgContentBVecStorage, msgContentLength), new TxHash(Fr.fromString(txHash)), Fr.fromString(logIndexInTx).toNumber(), Fr.fromString(txIndexInBlock).toNumber());
+        return [];
+    }
+}

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

@@ -0,0 +1,24 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type ACVMWitness, type CircuitSimulator } from '@aztec/simulator/client';
+import { type FunctionArtifact, type FunctionArtifactWithContractName, type FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstance } from '@aztec/stdlib/contract';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+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.
+ */
+export declare function executePrivateFunction(simulator: CircuitSimulator, privateExecutionOracle: PrivateExecutionOracle, artifact: FunctionArtifactWithContractName, contractAddress: AztecAddress, functionSelector: FunctionSelector, log?: import("@aztec/foundation/log").Logger): Promise<PrivateCallExecutionResult>;
+/**
+ * Get the private circuit public inputs from the partial witness.
+ * @param artifact - The function artifact
+ * @param partialWitness - The partial witness, result of simulating the function.
+ * @returns - The public inputs.
+ */
+export declare function extractPrivateCircuitPublicInputs(artifact: FunctionArtifact, partialWitness: ACVMWitness): PrivateCircuitPublicInputs;
+export declare function readCurrentClassId(contractAddress: AztecAddress, instance: ContractInstance, executionDataProvider: ExecutionDataProvider | AztecNode, blockNumber: number): Promise<Fr>;
+export declare function verifyCurrentClassId(contractAddress: AztecAddress, executionDataProvider: ExecutionDataProvider, blockNumber?: number): Promise<void>;
+//# sourceMappingURL=private_execution.d.ts.map

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

@@ -0,0 +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,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAE9D,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,CAyErC;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,gBAAgB,EAC1B,cAAc,EAAE,WAAW,GAC1B,0BAA0B,CAa5B;AAED,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,qBAAqB,EAAE,qBAAqB,GAAG,SAAS,EACxD,WAAW,EAAE,MAAM,eAWpB;AAED,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,YAAY,EAC7B,qBAAqB,EAAE,qBAAqB,EAC5C,WAAW,CAAC,EAAE,MAAM,iBAUrB"}

package/dest/contract_function_simulator/oracle/private_execution.js

@@ -0,0 +1,100 @@
+import { PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+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 { 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.
+ */ 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}`, {
+        contract: contractAddress
+    });
+    const initialWitness = privateExecutionOracle.getInitialWitness(artifact);
+    const acvmCallback = new Oracle(privateExecutionOracle);
+    const timer = new Timer();
+    const acirExecutionResult = await simulator.executeUserCircuit(initialWitness, artifact, acvmCallback.toACIRCallback()).catch((err)=>{
+        err.message = resolveAssertionMessageFromError(err, artifact);
+        throw new ExecutionError(err.message, {
+            contractAddress,
+            functionSelector
+        }, extractCallStack(err, artifact.debug), {
+            cause: err
+        });
+    });
+    const duration = timer.ms();
+    const partialWitness = acirExecutionResult.partialWitness;
+    const publicInputs = extractPrivateCircuitPublicInputs(artifact, partialWitness);
+    // TODO (alexg) estimate this size
+    const initialWitnessSize = witnessMapToFields(initialWitness).length * Fr.SIZE_IN_BYTES;
+    log.debug(`Ran external function ${contractAddress.toString()}:${functionSelector}`, {
+        circuitName: 'app-circuit',
+        duration,
+        eventName: 'circuit-witness-generation',
+        inputSize: initialWitnessSize,
+        outputSize: publicInputs.toBuffer().length,
+        appCircuitName: functionName
+    });
+    const contractClassLogs = privateExecutionOracle.getContractClassLogs();
+    const rawReturnValues = await privateExecutionOracle.loadFromExecutionCache(publicInputs.returnsHash);
+    const noteHashLeafIndexMap = privateExecutionOracle.getNoteHashLeafIndexMap();
+    const newNotes = privateExecutionOracle.getNewNotes();
+    const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
+    const nestedExecutions = privateExecutionOracle.getNestedExecutions();
+    let timerSubtractionList = nestedExecutions;
+    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 ?? []);
+    }
+    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, nestedExecutions, contractClassLogs, {
+        timings: {
+            witgen: witgenTime,
+            oracles: acirExecutionResult.oracles
+        }
+    });
+}
+/**
+ * Get the private circuit public inputs from the partial witness.
+ * @param artifact - The function artifact
+ * @param partialWitness - The partial witness, result of simulating the function.
+ * @returns - The public inputs.
+ */ export function extractPrivateCircuitPublicInputs(artifact, partialWitness) {
+    const parametersSize = countArgumentsSize(artifact) + PRIVATE_CONTEXT_INPUTS_LENGTH;
+    const returnsSize = PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH;
+    const returnData = [];
+    // Return values always appear in the witness after arguments.
+    for(let i = parametersSize; i < parametersSize + returnsSize; i++){
+        const returnedField = partialWitness.get(i);
+        if (returnedField === undefined) {
+            throw new Error(`Missing return value for index ${i}`);
+        }
+        returnData.push(Fr.fromString(returnedField));
+    }
+    return PrivateCircuitPublicInputs.fromFields(returnData);
+}
+export async function readCurrentClassId(contractAddress, instance, executionDataProvider, blockNumber) {
+    const { sharedMutableSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
+    const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, (slot)=>executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceDeployer, slot));
+    let currentClassId = sharedMutableValues.svc.getCurrentAt(blockNumber)[0];
+    if (currentClassId.isZero()) {
+        currentClassId = instance.originalContractClassId;
+    }
+    return currentClassId;
+}
+export async function verifyCurrentClassId(contractAddress, executionDataProvider, blockNumber) {
+    const instance = await executionDataProvider.getContractInstance(contractAddress);
+    blockNumber = blockNumber ?? await executionDataProvider.getBlockNumber();
+    const currentClassId = await readCurrentClassId(contractAddress, instance, executionDataProvider, blockNumber);
+    if (!instance.currentContractClassId.equals(currentClassId)) {
+        throw new Error(`Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`);
+    }
+}

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

@@ -0,0 +1,187 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type CircuitSimulator } from '@aztec/simulator/client';
+import { type FunctionAbi, FunctionSelector, type NoteSelector } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassLog } from '@aztec/stdlib/logs';
+import { type NoteStatus } from '@aztec/stdlib/note';
+import { type BlockHeader, CallContext, Capsule, CountedContractClassLog, NoteAndSlot, PrivateCallExecutionResult, type TxContext } from '@aztec/stdlib/tx';
+import type { ExecutionDataProvider } from '../execution_data_provider.js';
+import type { ExecutionNoteCache } from '../execution_note_cache.js';
+import type { HashedValuesCache } from '../hashed_values_cache.js';
+import type { NoteData } from './typed_oracle.js';
+import { UtilityExecutionOracle } from './utility_execution_oracle.js';
+/**
+ * The execution oracle for the private part of a transaction.
+ */
+export declare class PrivateExecutionOracle extends UtilityExecutionOracle {
+    #private;
+    private readonly argsHash;
+    private readonly txContext;
+    private readonly callContext;
+    /** Header of a block whose state is used during private execution (not the block the transaction is included in). */
+    protected readonly historicalHeader: BlockHeader;
+    private readonly executionCache;
+    private readonly noteCache;
+    private simulator;
+    private totalPublicCalldataCount;
+    protected sideEffectCounter: number;
+    /**
+     * New notes created during this execution.
+     * It's possible that a note in this list has been nullified (in the same or other executions) and doesn't exist in the ExecutionNoteCache and the final proof data.
+     * But we still include those notes in the execution result because their commitments are still in the public inputs of this execution.
+     * This information is only for references (currently used for tests), and is not used for any sort of constrains.
+     * Users can also use this to get a clearer idea of what's happened during a simulation.
+     */
+    private newNotes;
+    /**
+     * Notes from previous transactions that are returned to the oracle call `getNotes` during this execution.
+     * The mapping maps from the unique siloed note hash to the index for notes created in private executions.
+     * It maps from siloed note hash to the index for notes created by public functions.
+     *
+     * They are not part of the ExecutionNoteCache and being forwarded to nested contexts via `extend()`
+     * because these notes are meant to be maintained on a per-call basis
+     * They should act as references for the read requests output by an app circuit via public inputs.
+     */
+    private noteHashLeafIndexMap;
+    private noteHashNullifierCounterMap;
+    private contractClassLogs;
+    private nestedExecutions;
+    constructor(argsHash: Fr, txContext: TxContext, callContext: CallContext, 
+    /** Header of a block whose state is used during private execution (not the block the transaction is included in). */
+    historicalHeader: BlockHeader, 
+    /** List of transient auth witnesses to be used during this simulation */
+    authWitnesses: AuthWitness[], capsules: Capsule[], executionCache: HashedValuesCache, noteCache: ExecutionNoteCache, executionDataProvider: ExecutionDataProvider, simulator: CircuitSimulator, totalPublicCalldataCount: number, sideEffectCounter?: number, log?: import("@aztec/foundation/log").Logger, scopes?: AztecAddress[]);
+    /**
+     * Writes the function inputs to the initial witness.
+     * @param abi - The function ABI.
+     * @returns The initial witness.
+     */
+    getInitialWitness(abi: FunctionAbi): Map<number, string>;
+    /**
+     * The KernelProver will use this to fully populate witnesses and provide hints to the kernel circuit
+     * regarding which note hash each settled read request corresponds to.
+     */
+    getNoteHashLeafIndexMap(): Map<bigint, bigint>;
+    /**
+     * Get the data for the newly created notes.
+     */
+    getNewNotes(): NoteAndSlot[];
+    getNoteHashNullifierCounterMap(): Map<number, number>;
+    /**
+     * Return the contract class logs emitted during this execution.
+     */
+    getContractClassLogs(): CountedContractClassLog[];
+    /**
+     * Return the nested execution results during this execution.
+     */
+    getNestedExecutions(): PrivateCallExecutionResult[];
+    /**
+     * Store values in the execution cache.
+     * @param values - Values to store.
+     * @returns The hash of the values.
+     */
+    storeInExecutionCache(values: Fr[], hash: Fr): void;
+    /**
+     * Gets values from the execution cache.
+     * @param hash - Hash of the values.
+     * @returns The values.
+     */
+    loadFromExecutionCache(hash: Fr): Promise<Fr[]>;
+    /**
+     * Gets some notes for a storage slot.
+     *
+     * @remarks
+     * Check for pending notes with matching slot.
+     * Real notes coming from DB will have a leafIndex which
+     * represents their index in the note hash tree.
+     *
+     * @param storageSlot - The storage slot.
+     * @param numSelects - The number of valid selects in selectBy and selectValues.
+     * @param selectBy - An array of indices of the fields to selects.
+     * @param selectValues - The values to match.
+     * @param selectComparators - The comparators to match by.
+     * @param sortBy - An array of indices of the fields to sort.
+     * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
+     * @param limit - The number of notes to retrieve per query.
+     * @param offset - The starting index for pagination.
+     * @param status - The status of notes to fetch.
+     * @returns Array of note data.
+     */
+    getNotes(storageSlot: Fr, numSelects: number, selectByIndexes: number[], selectByOffsets: number[], selectByLengths: number[], selectValues: Fr[], selectComparators: number[], sortByIndexes: number[], sortByOffsets: number[], sortByLengths: number[], sortOrder: number[], limit: number, offset: number, status: NoteStatus): Promise<NoteData[]>;
+    /**
+     * Keep track of the new note created during execution.
+     * It can be used in subsequent calls (or transactions when chaining txs is possible).
+     * @param contractAddress - The contract address.
+     * @param storageSlot - The storage slot.
+     * @param noteTypeId - The type ID of the note.
+     * @param noteItems - The items to be included in a Note.
+     * @param noteHash - A hash of the new note.
+     * @returns
+     */
+    notifyCreatedNote(storageSlot: Fr, noteTypeId: NoteSelector, noteItems: Fr[], noteHash: Fr, counter: number): void;
+    /**
+     * Adding a siloed nullifier into the current set of all pending nullifiers created
+     * within the current transaction/execution.
+     * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
+     * @param noteHash - A hash of the new note.
+     */
+    notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number): Promise<void>;
+    /**
+     * Adding a siloed nullifier into the current set of all pending nullifiers created
+     * within the current transaction/execution.
+     * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
+     * @param noteHash - A hash of the new note.
+     */
+    notifyCreatedNullifier(innerNullifier: Fr): Promise<void>;
+    /**
+     * Emit a contract class log.
+     * This fn exists because we only carry a poseidon hash through the kernels, and need to
+     * keep the preimage in ts for later.
+     * @param log - The contract class log to be emitted.
+     * @param counter - The contract class log's counter.
+     */
+    notifyCreatedContractClassLog(log: ContractClassLog, counter: number): void;
+    /**
+     * Calls a private function as a nested execution.
+     * @param targetContractAddress - The address of the contract to call.
+     * @param functionSelector - The function selector of the function to call.
+     * @param argsHash - The arguments hash to pass to the function.
+     * @param sideEffectCounter - The side effect counter at the start of the call.
+     * @param isStaticCall - Whether the call is a static call.
+     * @returns The execution result.
+     */
+    callPrivateFunction(targetContractAddress: AztecAddress, functionSelector: FunctionSelector, argsHash: Fr, sideEffectCounter: number, isStaticCall: boolean): Promise<{
+        endSideEffectCounter: Fr;
+        returnsHash: Fr;
+    }>;
+    /**
+     * Verify relevant information when a public function is enqueued.
+     * @param targetContractAddress - The address of the contract to call.
+     * @param calldataHash - The hash of the function selector and arguments.
+     * @param sideEffectCounter - The side effect counter at the start of the call.
+     * @param isStaticCall - Whether the call is a static call.
+     */
+    notifyEnqueuedPublicFunctionCall(_targetContractAddress: AztecAddress, calldataHash: Fr, _sideEffectCounter: number, _isStaticCall: boolean): Promise<void>;
+    /**
+     * Verify relevant information when a public teardown function is set.
+     * @param targetContractAddress - The address of the contract to call.
+     * @param argsHash - The arguments hash to pass to the function.
+     * @param sideEffectCounter - The side effect counter at the start of the call.
+     * @param isStaticCall - Whether the call is a static call.
+     */
+    notifySetPublicTeardownFunctionCall(_targetContractAddress: AztecAddress, calldataHash: Fr, _sideEffectCounter: number, _isStaticCall: boolean): Promise<void>;
+    notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void>;
+    /**
+     * Derives the call context for a nested execution.
+     * @param targetContractAddress - The address of the contract being called.
+     * @param targetArtifact - The artifact of the function being called.
+     * @param isStaticCall - Whether the call is a static call.
+     * @returns The derived call context.
+     */
+    private deriveCallContext;
+    getDebugFunctionName(): Promise<string>;
+    incrementAppTaggingSecretIndexAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<void>;
+    fetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;
+}
+//# sourceMappingURL=private_execution_oracle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"private_execution_oracle.d.ts","sourceRoot":"","sources":["../../../src/contract_function_simulator/oracle/private_execution_oracle.ts"],"names":[],"mappings":"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"}