@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/dest/contract_function_simulator/oracle/oracle.js

@@ -0,0 +1,368 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import { arrayOfArraysToBoundedVecOfArrays, bufferToBoundedVec, fromUintArray, fromUintBoundedVec, toACVMField } from '@aztec/simulator/client';
+import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
+import { ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
+import { packAsHintedNote } from './note_packing_utils.js';
+export class UnavailableOracleError extends Error {
+    constructor(oracleName){
+        super(`${oracleName} oracles not available with the current handler`);
+    }
+}
+/**
+ * A data source that has all the apis required by Aztec.nr.
+ */ export class Oracle {
+    handler;
+    constructor(handler){
+        this.handler = handler;
+    }
+    handlerAsMisc() {
+        if (!('isMisc' in this.handler)) {
+            throw new UnavailableOracleError('Misc');
+        }
+        return this.handler;
+    }
+    handlerAsUtility() {
+        if (!('isUtility' in this.handler)) {
+            throw new UnavailableOracleError('Utility');
+        }
+        return this.handler;
+    }
+    handlerAsPrivate() {
+        if (!('isPrivate' in this.handler)) {
+            throw new UnavailableOracleError('Private');
+        }
+        return this.handler;
+    }
+    toACIRCallback() {
+        const excludedProps = [
+            'handler',
+            'constructor',
+            'toACIRCallback',
+            'handlerAsMisc',
+            'handlerAsUtility',
+            'handlerAsPrivate'
+        ];
+        // 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;
+        }, {});
+    }
+    utilityAssertCompatibleOracleVersion([version]) {
+        this.handlerAsMisc().utilityAssertCompatibleOracleVersion(Fr.fromString(version).toNumber());
+        return Promise.resolve([]);
+    }
+    utilityGetRandomField() {
+        const val = this.handlerAsMisc().utilityGetRandomField();
+        return Promise.resolve([
+            toACVMField(val)
+        ]);
+    }
+    privateStoreInExecutionCache(values, [hash]) {
+        this.handlerAsPrivate().privateStoreInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
+        return Promise.resolve([]);
+    }
+    async privateLoadFromExecutionCache([returnsHash]) {
+        const values = await this.handlerAsPrivate().privateLoadFromExecutionCache(Fr.fromString(returnsHash));
+        return [
+            values.map(toACVMField)
+        ];
+    }
+    utilityGetUtilityContext() {
+        const context = this.handlerAsUtility().utilityGetUtilityContext();
+        return Promise.resolve(context.toNoirRepresentation());
+    }
+    async utilityGetKeyValidationRequest([pkMHash]) {
+        const keyValidationRequest = await this.handlerAsUtility().utilityGetKeyValidationRequest(Fr.fromString(pkMHash));
+        return keyValidationRequest.toFields().map(toACVMField);
+    }
+    async utilityGetContractInstance([address]) {
+        const instance = await this.handlerAsUtility().utilityGetContractInstance(AztecAddress.fromField(Fr.fromString(address)));
+        return [
+            instance.salt,
+            instance.deployer,
+            instance.currentContractClassId,
+            instance.initializationHash,
+            ...instance.publicKeys.toFields()
+        ].map(toACVMField);
+    }
+    async utilityGetNoteHashMembershipWitness([anchorBlockHash], [noteHash]) {
+        const parsedAnchorBlockHash = BlockHash.fromString(anchorBlockHash);
+        const parsedNoteHash = Fr.fromString(noteHash);
+        const witness = await this.handlerAsUtility().utilityGetNoteHashMembershipWitness(parsedAnchorBlockHash, parsedNoteHash);
+        if (!witness) {
+            throw new Error(`Note hash ${noteHash} not found in the note hash tree at anchor block hash ${parsedAnchorBlockHash.toString()}.`);
+        }
+        return witness.toNoirRepresentation();
+    }
+    async utilityGetBlockHashMembershipWitness([anchorBlockHash], [blockHash]) {
+        const parsedAnchorBlockHash = BlockHash.fromString(anchorBlockHash);
+        const parsedBlockHash = BlockHash.fromString(blockHash);
+        const witness = await this.handlerAsUtility().utilityGetBlockHashMembershipWitness(parsedAnchorBlockHash, parsedBlockHash);
+        if (!witness) {
+            throw new Error(`Block hash ${parsedBlockHash.toString()} not found in the archive tree at anchor block ${parsedAnchorBlockHash.toString()}.`);
+        }
+        return witness.toNoirRepresentation();
+    }
+    async utilityGetNullifierMembershipWitness([blockHash], [nullifier]) {
+        const parsedBlockHash = BlockHash.fromString(blockHash);
+        const parsedNullifier = Fr.fromString(nullifier);
+        const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(parsedBlockHash, parsedNullifier);
+        if (!witness) {
+            throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`);
+        }
+        return witness.toNoirRepresentation();
+    }
+    async utilityGetLowNullifierMembershipWitness([blockHash], [nullifier]) {
+        const parsedBlockHash = BlockHash.fromString(blockHash);
+        const parsedNullifier = Fr.fromString(nullifier);
+        const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(parsedBlockHash, parsedNullifier);
+        if (!witness) {
+            throw new Error(`Low nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`);
+        }
+        return witness.toNoirRepresentation();
+    }
+    async utilityGetPublicDataWitness([blockHash], [leafSlot]) {
+        const parsedBlockHash = BlockHash.fromString(blockHash);
+        const parsedLeafSlot = Fr.fromString(leafSlot);
+        const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(parsedBlockHash, parsedLeafSlot);
+        if (!witness) {
+            throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block hash ${parsedBlockHash.toString()}.`);
+        }
+        return witness.toNoirRepresentation();
+    }
+    async utilityGetBlockHeader([blockNumber]) {
+        const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+        const header = await this.handlerAsUtility().utilityGetBlockHeader(BlockNumber(parsedBlockNumber));
+        if (!header) {
+            throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
+        }
+        return header.toFields().map(toACVMField);
+    }
+    async utilityGetAuthWitness([messageHash]) {
+        const messageHashField = Fr.fromString(messageHash);
+        const witness = await this.handlerAsUtility().utilityGetAuthWitness(messageHashField);
+        if (!witness) {
+            throw new Error(`Unknown auth witness for message hash ${messageHashField}`);
+        }
+        return [
+            witness.map(toACVMField)
+        ];
+    }
+    async utilityTryGetPublicKeysAndPartialAddress([address]) {
+        const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
+        const result = await this.handlerAsUtility().utilityTryGetPublicKeysAndPartialAddress(parsedAddress);
+        // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
+        // with two fields: `some` (a boolean) and `value` (a field array in this case).
+        if (result === undefined) {
+            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
+            return [
+                toACVMField(0),
+                Array(13).fill(toACVMField(0))
+            ];
+        } else {
+            // Data was found so we set `some` to 1 and return it along with `value`.
+            return [
+                toACVMField(1),
+                [
+                    ...result.publicKeys.toFields(),
+                    result.partialAddress
+                ].map(toACVMField)
+            ];
+        }
+    }
+    async utilityGetNotes([ownerSome], [ownerValue], [storageSlot], [numSelects], selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, [limit], [offset], [status], [maxNotes], [packedHintedNoteLength]) {
+        // Parse Option<AztecAddress>: ownerSome is 0 for None, 1 for Some
+        const owner = Fr.fromString(ownerSome).toNumber() === 1 ? AztecAddress.fromString(ownerValue) : undefined;
+        const noteDatas = await this.handlerAsUtility().utilityGetNotes(owner, Fr.fromString(storageSlot), +numSelects, selectByIndexes.map((s)=>+s), selectByOffsets.map((s)=>+s), selectByLengths.map((s)=>+s), selectValues.map(Fr.fromString), selectComparators.map((s)=>+s), sortByIndexes.map((s)=>+s), sortByOffsets.map((s)=>+s), sortByLengths.map((s)=>+s), sortOrder.map((s)=>+s), +limit, +offset, +status);
+        const returnDataAsArrayOfPackedHintedNotes = noteDatas.map((noteData)=>packAsHintedNote({
+                contractAddress: noteData.contractAddress,
+                owner: noteData.owner,
+                randomness: noteData.randomness,
+                storageSlot: noteData.storageSlot,
+                noteNonce: noteData.noteNonce,
+                isPending: noteData.isPending,
+                note: noteData.note
+            }));
+        // Now we convert each sub-array to an array of ACVMField
+        const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedHintedNotes.map((subArray)=>subArray.map(toACVMField));
+        // At last we convert the array of arrays to a bounded vec of arrays
+        return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedHintedNoteLength);
+    }
+    privateNotifyCreatedNote([owner], [storageSlot], [randomness], [noteTypeId], note, [noteHash], [counter]) {
+        this.handlerAsPrivate().privateNotifyCreatedNote(AztecAddress.fromString(owner), Fr.fromString(storageSlot), Fr.fromString(randomness), NoteSelector.fromField(Fr.fromString(noteTypeId)), note.map(Fr.fromString), Fr.fromString(noteHash), +counter);
+        return Promise.resolve([]);
+    }
+    async privateNotifyNullifiedNote([innerNullifier], [noteHash], [counter]) {
+        await this.handlerAsPrivate().privateNotifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
+        return [];
+    }
+    async privateNotifyCreatedNullifier([innerNullifier]) {
+        await this.handlerAsPrivate().privateNotifyCreatedNullifier(Fr.fromString(innerNullifier));
+        return [];
+    }
+    async privateIsNullifierPending([innerNullifier], [contractAddress]) {
+        const isPending = await this.handlerAsPrivate().privateIsNullifierPending(Fr.fromString(innerNullifier), AztecAddress.fromString(contractAddress));
+        return [
+            toACVMField(isPending)
+        ];
+    }
+    async utilityCheckNullifierExists([innerNullifier]) {
+        const exists = await this.handlerAsUtility().utilityCheckNullifierExists(Fr.fromString(innerNullifier));
+        return [
+            toACVMField(exists)
+        ];
+    }
+    async utilityGetL1ToL2MembershipWitness([contractAddress], [messageHash], [secret]) {
+        const message = await this.handlerAsUtility().utilityGetL1ToL2MembershipWitness(AztecAddress.fromString(contractAddress), Fr.fromString(messageHash), Fr.fromString(secret));
+        return message.toNoirRepresentation();
+    }
+    async utilityStorageRead([blockHash], [contractAddress], [startStorageSlot], [numberOfElements]) {
+        const values = await this.handlerAsUtility().utilityStorageRead(BlockHash.fromString(blockHash), new AztecAddress(Fr.fromString(contractAddress)), Fr.fromString(startStorageSlot), +numberOfElements);
+        return [
+            values.map(toACVMField)
+        ];
+    }
+    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.handlerAsPrivate().privateNotifyCreatedContractClassLog(log, +counter);
+        return Promise.resolve([]);
+    }
+    utilityDebugLog(level, message, _ignoredFieldsSize, fields) {
+        const levelFr = Fr.fromString(level[0]);
+        const messageStr = message.map((acvmField)=>String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
+        const fieldsFr = fields.map(Fr.fromString);
+        this.handlerAsMisc().utilityDebugLog(levelFr.toNumber(), messageStr, fieldsFr);
+        return Promise.resolve([]);
+    }
+    // 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.handlerAsPrivate().privateCallPrivateFunction(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 privateNotifyEnqueuedPublicFunctionCall([contractAddress], [calldataHash], [sideEffectCounter], [isStaticCall]) {
+        await this.handlerAsPrivate().privateNotifyEnqueuedPublicFunctionCall(AztecAddress.fromString(contractAddress), Fr.fromString(calldataHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
+        return [];
+    }
+    async privateNotifySetPublicTeardownFunctionCall([contractAddress], [calldataHash], [sideEffectCounter], [isStaticCall]) {
+        await this.handlerAsPrivate().privateNotifySetPublicTeardownFunctionCall(AztecAddress.fromString(contractAddress), Fr.fromString(calldataHash), Fr.fromString(sideEffectCounter).toNumber(), Fr.fromString(isStaticCall).toBool());
+        return [];
+    }
+    async privateNotifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]) {
+        await this.handlerAsPrivate().privateNotifySetMinRevertibleSideEffectCounter(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
+        return Promise.resolve([]);
+    }
+    async privateIsSideEffectCounterRevertible([sideEffectCounter]) {
+        const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(Fr.fromString(sideEffectCounter).toNumber());
+        return Promise.resolve([
+            toACVMField(isRevertible)
+        ]);
+    }
+    async privateGetNextAppTagAsSender([sender], [recipient]) {
+        const tag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(AztecAddress.fromString(sender), AztecAddress.fromString(recipient));
+        return [
+            toACVMField(tag.value)
+        ];
+    }
+    async utilityFetchTaggedLogs([pendingTaggedLogArrayBaseSlot]) {
+        await this.handlerAsUtility().utilityFetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
+        return [];
+    }
+    async utilityValidateAndStoreEnqueuedNotesAndEvents([contractAddress], [noteValidationRequestsArrayBaseSlot], [eventValidationRequestsArrayBaseSlot]) {
+        await this.handlerAsUtility().utilityValidateAndStoreEnqueuedNotesAndEvents(AztecAddress.fromString(contractAddress), Fr.fromString(noteValidationRequestsArrayBaseSlot), Fr.fromString(eventValidationRequestsArrayBaseSlot));
+        return [];
+    }
+    async utilityBulkRetrieveLogs([contractAddress], [logRetrievalRequestsArrayBaseSlot], [logRetrievalResponsesArrayBaseSlot]) {
+        await this.handlerAsUtility().utilityBulkRetrieveLogs(AztecAddress.fromString(contractAddress), Fr.fromString(logRetrievalRequestsArrayBaseSlot), Fr.fromString(logRetrievalResponsesArrayBaseSlot));
+        return [];
+    }
+    async utilityStoreCapsule([contractAddress], [slot], capsule) {
+        await this.handlerAsUtility().utilityStoreCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot), capsule.map(Fr.fromString));
+        return [];
+    }
+    async utilityLoadCapsule([contractAddress], [slot], [tSize]) {
+        const values = await this.handlerAsUtility().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) {
+            // 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 utilityDeleteCapsule([contractAddress], [slot]) {
+        await this.handlerAsUtility().utilityDeleteCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(slot));
+        return [];
+    }
+    async utilityCopyCapsule([contractAddress], [srcSlot], [dstSlot], [numEntries]) {
+        await this.handlerAsUtility().utilityCopyCapsule(AztecAddress.fromField(Fr.fromString(contractAddress)), Fr.fromString(srcSlot), Fr.fromString(dstSlot), Fr.fromString(numEntries).toNumber());
+        return [];
+    }
+    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.handlerAsUtility().utilityAes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
+        return bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
+    }
+    async utilityGetSharedSecret([address], [ephPKField0], [ephPKField1], [ephPKField2]) {
+        const secret = await this.handlerAsUtility().utilityGetSharedSecret(AztecAddress.fromField(Fr.fromString(address)), Point.fromFields([
+            ephPKField0,
+            ephPKField1,
+            ephPKField2
+        ].map(Fr.fromString)));
+        return secret.toFields().map(toACVMField);
+    }
+    async utilityEmitOffchainEffect(data) {
+        await this.handlerAsPrivate().utilityEmitOffchainEffect(data.map(Fr.fromString));
+        return [];
+    }
+    async privateGetSenderForTags() {
+        const sender = await this.handlerAsPrivate().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.handlerAsPrivate().privateSetSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
+        return [];
+    }
+}

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

@@ -0,0 +1,23 @@
+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 { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+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>;
+/**
+ * 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;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9leGVjdXRpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb250cmFjdF9mdW5jdGlvbl9zaW11bGF0b3Ivb3JhY2xlL3ByaXZhdGVfZXhlY3V0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFDTCxLQUFLLFdBQVcsRUFDaEIsS0FBSyxnQkFBZ0IsRUFLdEIsTUFBTSx5QkFBeUIsQ0FBQztBQUNqQyxPQUFPLEVBQ0wsS0FBSyxnQkFBZ0IsRUFDckIsS0FBSyxnQ0FBZ0MsRUFDckMsS0FBSyxnQkFBZ0IsRUFFdEIsTUFBTSxtQkFBbUIsQ0FBQztBQUMzQixPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVsRSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUc5RCxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRTVFOzs7Ozs7O0dBT0c7QUFDSCx3QkFBc0Isc0JBQXNCLENBQzFDLFNBQVMsRUFBRSxnQkFBZ0IsRUFDM0Isc0JBQXNCLEVBQUUsc0JBQXNCLEVBQzlDLFFBQVEsRUFBRSxnQ0FBZ0MsRUFDMUMsZUFBZSxFQUFFLFlBQVksRUFDN0IsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQ2xDLEdBQUcseUNBQThDLEdBQ2hELE9BQU8sQ0FBQywwQkFBMEIsQ0FBQyxDQTJFckM7QUFFRDs7Ozs7R0FLRztBQUNILHdCQUFnQixpQ0FBaUMsQ0FDL0MsUUFBUSxFQUFFLGdCQUFnQixFQUMxQixjQUFjLEVBQUUsV0FBVyxHQUMxQiwwQkFBMEIsQ0FhNUIifQ==

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":"AAIA,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,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE,OAAO,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAG9D,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"}

package/dest/contract_function_simulator/oracle/private_execution.js

@@ -0,0 +1,87 @@
+import { PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ExecutionError, extractCallStack, resolveAssertionMessageFromError, witnessMapToFields } from '@aztec/simulator/client';
+import { countArgumentsSize } from '@aztec/stdlib/abi';
+import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
+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}`, {
+        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.privateLoadFromExecutionCache(publicInputs.returnsHash);
+    const newNotes = privateExecutionOracle.getNewNotes();
+    const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
+    const offchainEffects = privateExecutionOracle.getOffchainEffects();
+    const preTags = privateExecutionOracle.getUsedPreTags();
+    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.nestedExecutionResults ?? []);
+    }
+    log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
+    return new PrivateCallExecutionResult(artifact.bytecode, Buffer.from(artifact.verificationKey, 'base64'), partialWitness, publicInputs, newNotes, noteHashNullifierCounterMap, rawReturnValues, offchainEffects, preTags, nestedExecutionResults, 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);
+}