@aztec/simulator 0.87.5 → 0.87.7

package/dest/private/providers/circuit_recording/circuit_recorder.js

@@ -1,246 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { createHash } from 'crypto';
-import fs from 'fs/promises';
-import path from 'path';
-import { Oracle } from '../../acvm/oracle/oracle.js';
-/**
- * Class responsible for recording circuit inputs necessary to replay the circuit. These inputs are the initial witness
- * map and the oracle calls made during the circuit execution/witness generation.
- *
- * The recording is stored in a JSON file called `circuit_name_circuit_function_name_YYYY-MM-DD_N.json` where N is
- * a counter to ensure unique filenames. The file is stored in the `recordDir` directory provided as a parameter to
- * CircuitRecorder.start().
- *
- * Example recording file:
- * ```json
- * {
- *   "circuitName": "AMM",
- *   "functionName": "add_liquidity",
- *   "bytecodeMd5Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
- *   "timestamp": 1740691464360,
- *   "inputs": {
- *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
- *     "1": "0x00f4d59c0ff773427bb0fed5b422557ca4dc5655abe53d31fa9408cb3c5a672f",
- *     "5": "0x000000000000000000000000000000000000000000000000000000000000000f"
- *   },
- *   "oracleCalls": [
- *     {
- *       "name": "loadCapsule",
- *       "inputs": [
- *         [
- *           "0x102422483bad6abd385948435667e144ac4c272576e325e7563608876cd446fd"
- *         ],
- *         [
- *           "0x000000000000000000000000000000000000000000000000000000000000004d"
- *         ],
- *         [
- *           "0x0000000000000000000000000000000000000000000000000000000000000001"
- *         ]
- *       ],
- *       "outputs": [
- *         "0x0000000000000000000000000000000000000000000000000000000000000000",
- *         [
- *           "0x0000000000000000000000000000000000000000000000000000000000000000"
- *         ]
- *       ]
- *     },
- *     {
- *       "name": "syncPrivateState",
- *       "inputs": []
- *     }
- *   ]
- * }
- * ```
- */ export class CircuitRecorder {
-    filePath;
-    logger;
-    isFirstCall;
-    constructor(filePath){
-        this.filePath = filePath;
-        this.logger = createLogger('simulator:acvm:recording');
-        this.isFirstCall = true;
-    }
-    /**
-   * Initializes a new circuit recording session.
-   * @param recordDir - Directory to store the recording
-   * @param input - Circuit input witness
-   * @param circuitBytecode - Compiled circuit bytecode
-   * @param circuitName - Name of the circuit
-   * @param functionName - Name of the circuit function (defaults to 'main'). This is meaningful only for
-   * contracts as protocol circuits artifacts always contain a single entrypoint function called 'main'.
-   * @returns A new CircuitRecorder instance
-   */ static async start(recordDir, input, circuitBytecode, circuitName, functionName = 'main') {
-        const recording = {
-            circuitName: circuitName,
-            functionName: functionName,
-            bytecodeMd5Hash: createHash('md5').update(circuitBytecode).digest('hex'),
-            timestamp: Date.now(),
-            inputs: Object.fromEntries(input)
-        };
-        const recordingStringWithoutClosingBracket = JSON.stringify(recording, null, 2).slice(0, -2);
-        try {
-            // Check if the recording directory exists and is a directory
-            const stats = await fs.stat(recordDir);
-            if (!stats.isDirectory()) {
-                throw new Error(`Recording path ${recordDir} exists but is not a directory`);
-            }
-        } catch (err) {
-            if (err.code === 'ENOENT') {
-                // The directory does not exist so we create it
-                await fs.mkdir(recordDir, {
-                    recursive: true
-                });
-            } else {
-                throw err;
-            }
-        }
-        const filePath = await CircuitRecorder.#computeFilePathAndStoreInitialRecording(recordDir, circuitName, functionName, recordingStringWithoutClosingBracket);
-        return new CircuitRecorder(filePath);
-    }
-    /**
-   * Computes a unique file path for the recording by trying different counter values.
-   * This is needed because multiple recordings of the same circuit could be happening simultaneously or an older
-   * recording might be present.
-   * @param recordDir - Directory to store the recording
-   * @param circuitName - Name of the circuit
-   * @param functionName - Name of the circuit function
-   * @param recordingContent - Initial recording content
-   * @returns A unique file path for the recording
-   */ static async #computeFilePathAndStoreInitialRecording(recordDir, circuitName, functionName, recordingContent) {
-        let counter = 0;
-        while(true){
-            try {
-                const filePath = getFilePath(recordDir, circuitName, functionName, counter);
-                // Write the initial recording content to the file
-                await fs.writeFile(filePath, recordingContent + ',\n  "oracleCalls": [\n', {
-                    flag: 'wx'
-                });
-                return filePath;
-            } catch (err) {
-                if (err.code === 'EEXIST') {
-                    counter++;
-                    continue;
-                }
-                throw err;
-            }
-        }
-    }
-    /**
-   * Wraps a callback to record all oracle/foreign calls.
-   * @param callback - The original callback to wrap, either a user circuit callback or protocol circuit callback.
-   * @returns A wrapped callback that records all oracle interactions.
-   */ wrapCallback(callback) {
-        if (!callback) {
-            return undefined;
-        }
-        if (this.#isACIRCallback(callback)) {
-            return this.#wrapUserCircuitCallback(callback);
-        }
-        return this.#wrapProtocolCircuitCallback(callback);
-    }
-    /**
-   * Type guard to check if a callback is an ACIRCallback.
-   */ #isACIRCallback(callback) {
-        return typeof callback === 'object' && callback !== null && !('call' in callback);
-    }
-    /**
-   * Wraps a user circuit callback to record all oracle calls.
-   * @param callback - The original circuit callback.
-   * @returns A wrapped callback that records all oracle interactions which is to be provided to the ACVM.
-   */ #wrapUserCircuitCallback(callback) {
-        const recordingCallback = {};
-        const oracleMethods = Object.getOwnPropertyNames(Oracle.prototype).filter((name)=>name !== 'constructor');
-        for (const name of oracleMethods){
-            const fn = callback[name];
-            if (!fn) {
-                throw new Error(`Oracle method ${name} not found when setting up recording callback`);
-            }
-            recordingCallback[name] = (...args)=>{
-                const result = fn.call(callback, ...args);
-                if (result instanceof Promise) {
-                    return result.then(async (r)=>{
-                        await this.#recordCall(name, args, r);
-                        return r;
-                    });
-                }
-                void this.#recordCall(name, args, result);
-                return result;
-            };
-        }
-        return recordingCallback;
-    }
-    /**
-   * Wraps a protocol circuit callback to record all oracle calls.
-   * @param callback - The original oracle circuit callback.
-   * @returns A wrapped handler that records all oracle interactions which is to be provided to the ACVM.
-   */ #wrapProtocolCircuitCallback(callback) {
-        return async (name, inputs)=>{
-            const result = await callback(name, inputs);
-            await this.#recordCall(name, inputs, result);
-            return result;
-        };
-    }
-    /**
-   * Records a single oracle/foreign call with its inputs and outputs.
-   * @param name - Name of the call
-   * @param inputs - Input arguments
-   * @param outputs - Output results
-   */ async #recordCall(name, inputs, outputs) {
-        try {
-            const entry = {
-                name,
-                inputs,
-                outputs
-            };
-            const prefix = this.isFirstCall ? '    ' : '    ,';
-            this.isFirstCall = false;
-            await fs.appendFile(this.filePath, prefix + JSON.stringify(entry) + '\n');
-        } catch (err) {
-            this.logger.error('Failed to log circuit call', {
-                error: err
-            });
-        }
-    }
-    /**
-   * Finalizes the recording file by adding closing brackets. Without calling this method, the recording file is
-   * incomplete and it fails to parse.
-   */ async finish() {
-        try {
-            await fs.appendFile(this.filePath, '  ]\n}\n');
-        } catch (err) {
-            this.logger.error('Failed to finalize recording file', {
-                error: err
-            });
-        }
-    }
-    /**
-   * Finalizes the recording file by adding the error and closing brackets. Without calling this method or `finish`,
-   * the recording file is incomplete and it fails to parse.
-   * @param error - The error that occurred during circuit execution
-   */ async finishWithError(error) {
-        try {
-            await fs.appendFile(this.filePath, '  ],\n');
-            await fs.appendFile(this.filePath, `  "error": ${JSON.stringify(error)}\n`);
-            await fs.appendFile(this.filePath, '}\n');
-        } catch (err) {
-            this.logger.error('Failed to finalize recording file with error', {
-                error: err
-            });
-        }
-    }
-}
-/**
- * Generates a file path for storing circuit recordings. The format of the filename is:
- * `circuit_name_circuit_function_name_YYYY-MM-DD_N.json` where N is a counter to ensure unique filenames.
- * @param recordDir - Base directory for recordings
- * @param circuitName - Name of the circuit
- * @param functionName - Name of the circuit function
- * @param counter - Counter to ensure unique filenames. This is expected to be incremented in a loop until there is no
- * existing file with the same name.
- * @returns A file path for the recording.
- */ function getFilePath(recordDir, circuitName, functionName, counter) {
-    const date = new Date();
-    const formattedDate = date.toISOString().split('T')[0];
-    const filename = `${circuitName}_${functionName}_${formattedDate}_${counter}.json`;
-    return path.join(recordDir, filename);
-}

package/dest/private/providers/circuit_recording/simulation_provider_recorder_wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulation_provider_recorder_wrapper.d.ts","sourceRoot":"","sources":["../../../../src/private/providers/circuit_recording/simulation_provider_recorder_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AACpF,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAGpE;;;GAGG;AACH,qBAAa,iCAAkC,YAAW,kBAAkB;;IAC9D,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,kBAAkB;IAEjD,sBAAsB,CACpB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC;IAavB,kBAAkB,CAChB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC;CA4ChC"}

package/dest/private/providers/factory.d.ts

@@ -1,12 +0,0 @@
-import { type Logger } from '@aztec/foundation/log';
-import type { SimulationProvider } from './simulation_provider.js';
-export type SimulationProviderConfig = {
-    acvmBinaryPath?: string;
-    acvmWorkingDirectory?: string;
-};
-export declare function getSimulationProviderConfigFromEnv(): {
-    acvmWorkingDirectory: string | undefined;
-    acvmBinaryPath: string | undefined;
-};
-export declare function createSimulationProvider(config: SimulationProviderConfig, logger?: Logger): Promise<SimulationProvider>;
-//# sourceMappingURL=factory.d.ts.map

package/dest/private/providers/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/private/providers/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAMlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,MAAM,wBAAwB,GAAG;IACrC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAgB,kCAAkC;;;EAMjD;AAED,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,wBAAwB,EAChC,MAAM,GAAE,MAAkC,GACzC,OAAO,CAAC,kBAAkB,CAAC,CAa7B"}

package/dest/private/providers/simulation_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulation_provider.d.ts","sourceRoot":"","sources":["../../../src/private/providers/simulation_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAE3F,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAoB,MAAM,iBAAiB,CAAC;AAChG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;OAOG;IACH,sBAAsB,CACpB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC,CAAC;IAExB;;;;;;;OAOG;IACH,kBAAkB,CAChB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACjC;AAED,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG;IAAE,uBAAuB,CAAC,EAAE,GAAG,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAIxG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,mBAAmB,EAAE,aAAa,EAAE,cAAc,GAAG,YAAY,CA0C1G"}

package/dest/private/simulator.d.ts

@@ -1,36 +0,0 @@
-import type { AbiDecoded, FunctionCall } from '@aztec/stdlib/abi';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { PrivateExecutionResult, TxExecutionRequest } from '@aztec/stdlib/tx';
-import type { ExecutionDataProvider } from './execution_data_provider.js';
-import type { SimulationProvider } from './providers/simulation_provider.js';
-/**
- * The ACIR simulator.
- */
-export declare class AcirSimulator {
-    private executionDataProvider;
-    private simulationProvider;
-    private log;
-    constructor(executionDataProvider: ExecutionDataProvider, simulationProvider: SimulationProvider);
-    /**
-     * Runs a private function.
-     * @param request - The transaction request.
-     * @param entryPointArtifact - The artifact of the entry point function.
-     * @param contractAddress - The address of the contract (should match request.origin)
-     * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract or a specific account.
-     * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-     * @returns The result of the execution.
-     */
-    run(request: TxExecutionRequest, contractAddress: AztecAddress, selector: FunctionSelector, msgSender?: AztecAddress, scopes?: AztecAddress[]): Promise<PrivateExecutionResult>;
-    /**
-     * Runs a utility function.
-     * @param call - The function call to execute.
-     * @param authwits - Authentication witnesses required for the function call.
-     * @param scopes - Optional array of account addresses whose notes can be accessed in this call. Defaults to all
-     * accounts if not specified.
-     * @returns A decoded ABI value containing the function's return data.
-     */
-    runUtility(call: FunctionCall, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<AbiDecoded>;
-}
-//# sourceMappingURL=simulator.d.ts.map

package/dest/private/simulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulator.d.ts","sourceRoot":"","sources":["../../src/private/simulator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAA+B,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAA6B,sBAAsB,EAAE,kBAAkB,EAAiB,MAAM,kBAAkB,CAAC;AAIxH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAK1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAG7E;;GAEG;AACH,qBAAa,aAAa;IAItB,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,kBAAkB;IAJ5B,OAAO,CAAC,GAAG,CAAS;gBAGV,qBAAqB,EAAE,qBAAqB,EAC5C,kBAAkB,EAAE,kBAAkB;IAKhD;;;;;;;;OAQG;IACU,GAAG,CACd,OAAO,EAAE,kBAAkB,EAC3B,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,eAA6C,EACtD,MAAM,CAAC,EAAE,YAAY,EAAE,GACtB,OAAO,CAAC,sBAAsB,CAAC;IA2ElC;;;;;;;OAOG;IACU,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;CAwCnH"}

package/dest/private/simulator.js

@@ -1,104 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CallContext, HashedValues, PrivateExecutionResult, collectNested } from '@aztec/stdlib/tx';
-import { ExecutionError, createSimulationError, resolveAssertionMessageFromError } from '../common/errors.js';
-import { Oracle, extractCallStack, toACVMWitness, witnessMapToFields } from './acvm/index.js';
-import { ExecutionNoteCache } from './execution_note_cache.js';
-import { HashedValuesCache } from './hashed_values_cache.js';
-import { executePrivateFunction, verifyCurrentClassId } from './private_execution.js';
-import { PrivateExecutionOracle } from './private_execution_oracle.js';
-import { UtilityExecutionOracle } from './utility_execution_oracle.js';
-/**
- * The ACIR simulator.
- */ export class AcirSimulator {
-    executionDataProvider;
-    simulationProvider;
-    log;
-    constructor(executionDataProvider, simulationProvider){
-        this.executionDataProvider = executionDataProvider;
-        this.simulationProvider = simulationProvider;
-        this.log = createLogger('simulator');
-    }
-    /**
-   * Runs a private function.
-   * @param request - The transaction request.
-   * @param entryPointArtifact - The artifact of the entry point function.
-   * @param contractAddress - The address of the contract (should match request.origin)
-   * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract or a specific account.
-   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-   * @returns The result of the execution.
-   */ async run(request, contractAddress, selector, msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE), scopes) {
-        const header = await this.executionDataProvider.getBlockHeader();
-        await verifyCurrentClassId(contractAddress, this.executionDataProvider);
-        const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
-        if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
-            throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
-        }
-        if (request.origin !== contractAddress) {
-            this.log.warn(`Request origin does not match contract address in simulation. Request origin: ${request.origin}, contract address: ${contractAddress}`);
-        }
-        // reserve the first side effect for the tx hash (inserted by the private kernel)
-        const startSideEffectCounter = 1;
-        const callContext = new CallContext(msgSender, contractAddress, await FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters), entryPointArtifact.isStatic);
-        const txRequestHash = await request.toTxRequest().hash();
-        const noteCache = new ExecutionNoteCache(txRequestHash);
-        const context = new PrivateExecutionOracle(request.firstCallArgsHash, request.txContext, callContext, header, request.authWitnesses, request.capsules, HashedValuesCache.create(request.argsOfCalls), noteCache, this.executionDataProvider, this.simulationProvider, /*totalPublicArgsCount=*/ 0, startSideEffectCounter, undefined, scopes);
-        try {
-            const executionResult = await executePrivateFunction(this.simulationProvider, context, entryPointArtifact, contractAddress, request.functionSelector);
-            const { usedTxRequestHashForNonces } = noteCache.finish();
-            const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
-            const publicCallRequests = collectNested([
-                executionResult
-            ], (r)=>[
-                    ...r.publicInputs.publicCallRequests.map((r)=>r.inner),
-                    r.publicInputs.publicTeardownCallRequest
-                ]).filter((r)=>!r.isEmpty());
-            const publicFunctionsCalldata = await Promise.all(publicCallRequests.map(async (r)=>{
-                const calldata = await context.loadFromExecutionCache(r.calldataHash);
-                return new HashedValues(calldata, r.calldataHash);
-            }));
-            return new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
-        } catch (err) {
-            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
-        }
-    }
-    // docs:start:execute_utility_function
-    /**
-   * Runs a utility function.
-   * @param call - The function call to execute.
-   * @param authwits - Authentication witnesses required for the function call.
-   * @param scopes - Optional array of account addresses whose notes can be accessed in this call. Defaults to all
-   * accounts if not specified.
-   * @returns A decoded ABI value containing the function's return data.
-   */ async runUtility(call, authwits, scopes) {
-        await verifyCurrentClassId(call.to, this.executionDataProvider);
-        const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(call.to, call.selector);
-        if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
-            throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
-        }
-        const oracle = new UtilityExecutionOracle(call.to, authwits, [], this.executionDataProvider, undefined, scopes);
-        try {
-            this.log.verbose(`Executing utility function ${entryPointArtifact.name}`, {
-                contract: call.to,
-                selector: call.selector
-            });
-            const initialWitness = toACVMWitness(0, call.args);
-            const acirExecutionResult = await this.simulationProvider.executeUserCircuit(initialWitness, entryPointArtifact, new Oracle(oracle)).catch((err)=>{
-                err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
-                throw new ExecutionError(err.message, {
-                    contractAddress: call.to,
-                    functionSelector: call.selector
-                }, extractCallStack(err, entryPointArtifact.debug), {
-                    cause: err
-                });
-            });
-            const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-            this.log.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
-            return decodeFromAbi(entryPointArtifact.returnTypes, returnWitness);
-        } catch (err) {
-            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
-        }
-    }
-}

package/dest/private/utility_execution_oracle.d.ts

@@ -1,163 +0,0 @@
-import { Fr, Point } from '@aztec/foundation/fields';
-import type { EventSelector } from '@aztec/stdlib/abi';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
-import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import { IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
-import type { NoteStatus } from '@aztec/stdlib/note';
-import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import type { BlockHeader, Capsule, TxHash } from '@aztec/stdlib/tx';
-import { type NoteData, TypedOracle } from './acvm/index.js';
-import type { ExecutionDataProvider } from './execution_data_provider.js';
-/**
- * The oracle for an execution of utility contract functions.
- */
-export declare class UtilityExecutionOracle extends TypedOracle {
-    protected readonly contractAddress: AztecAddress;
-    /** List of transient auth witnesses to be used during this simulation */
-    protected readonly authWitnesses: AuthWitness[];
-    protected readonly capsules: Capsule[];
-    protected readonly executionDataProvider: ExecutionDataProvider;
-    protected log: import("@aztec/foundation/log").Logger;
-    protected readonly scopes?: AztecAddress[] | undefined;
-    constructor(contractAddress: AztecAddress, 
-    /** List of transient auth witnesses to be used during this simulation */
-    authWitnesses: AuthWitness[], capsules: Capsule[], // TODO(#12425): Rename to transientCapsules
-    executionDataProvider: ExecutionDataProvider, log?: import("@aztec/foundation/log").Logger, scopes?: AztecAddress[] | undefined);
-    getBlockNumber(): Promise<number>;
-    getContractAddress(): Promise<AztecAddress>;
-    getChainId(): Promise<Fr>;
-    getVersion(): Promise<Fr>;
-    /**
-     * Retrieve keys associated with a specific master public key and app address.
-     * @param pkMHash - The master public key hash.
-     * @returns A Promise that resolves to nullifier keys.
-     * @throws If the keys are not registered in the key store.
-     */
-    getKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest>;
-    /**
-     * Fetches the index and sibling path of a leaf at a given block from a given tree.
-     * @param blockNumber - The block number at which to get the membership witness.
-     * @param treeId - Id of the tree to get the sibling path from.
-     * @param leafValue - The leaf value
-     * @returns The index and sibling path concatenated [index, sibling_path]
-     */
-    getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]>;
-    /**
-     * Returns a nullifier membership witness for a given nullifier at a given block.
-     * @param blockNumber - The block number at which to get the index.
-     * @param nullifier - Nullifier we try to find witness for.
-     * @returns The nullifier membership witness (if found).
-     */
-    getNullifierMembershipWitness(blockNumber: number, nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-    /**
-     * Returns a low nullifier membership witness for a given nullifier at a given block.
-     * @param blockNumber - The block number at which to get the index.
-     * @param nullifier - Nullifier we try to find the low nullifier witness for.
-     * @returns The low nullifier membership witness (if found).
-     * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
-     * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
-     * we are trying to prove non-inclusion for.
-     */
-    getLowNullifierMembershipWitness(blockNumber: number, nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-    /**
-     * Returns a public data tree witness for a given leaf slot at a given block.
-     * @param blockNumber - The block number at which to get the index.
-     * @param leafSlot - The slot of the public data tree to get the witness for.
-     * @returns - The witness
-     */
-    getPublicDataWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
-    /**
-     * Fetches a block header of a given block.
-     * @param blockNumber - The number of a block of which to get the block header.
-     * @returns Block extracted from a block with block number `blockNumber`.
-     */
-    getBlockHeader(blockNumber: number): Promise<BlockHeader | undefined>;
-    /**
-     * Retrieve the complete address associated to a given address.
-     * @param account - The account address.
-     * @returns A complete address associated with the input address.
-     * @throws An error if the account is not registered in the database.
-     */
-    getCompleteAddress(account: AztecAddress): Promise<CompleteAddress>;
-    /**
-     * Returns a contract instance associated with an address or throws if not found.
-     * @param address - Address.
-     * @returns A contract instance.
-     */
-    getContractInstance(address: AztecAddress): Promise<ContractInstance>;
-    /**
-     * Returns an auth witness for the given message hash. Checks on the list of transient witnesses
-     * for this transaction first, and falls back to the local database if not found.
-     * @param messageHash - Hash of the message to authenticate.
-     * @returns Authentication witness for the requested message hash.
-     */
-    getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
-    /**
-     * Gets some notes for a contract address and storage slot.
-     * Returns a flattened array containing filtered notes.
-     *
-     * @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 use to match values.
-     * @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[]>;
-    /**
-     * Check if a nullifier exists in the nullifier tree.
-     * @param innerNullifier - The inner nullifier.
-     * @returns A boolean indicating whether the nullifier exists in the tree or not.
-     */
-    checkNullifierExists(innerNullifier: Fr): Promise<boolean>;
-    /**
-     * Fetches a message from the executionDataProvider, given its key.
-     * @param contractAddress - Address of a contract by which the message was emitted.
-     * @param messageHash - Hash of the message.
-     * @param secret - Secret used to compute a nullifier.
-     * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
-     * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-     */
-    getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr): Promise<import("./message_load_oracle_inputs.js").MessageLoadOracleInputs<39>>;
-    /**
-     * Read the public storage data.
-     * @param contractAddress - The address to read storage from.
-     * @param startStorageSlot - The starting storage slot.
-     * @param blockNumber - The block number to read storage at.
-     * @param numberOfElements - Number of elements to read from the starting storage slot.
-     */
-    storageRead(contractAddress: AztecAddress, startStorageSlot: Fr, blockNumber: number, numberOfElements: number): Promise<Fr[]>;
-    debugLog(message: string, fields: Fr[]): void;
-    /**
-     * Returns the tagging secret for a given sender and recipient pair, siloed to the current contract address.
-     * Includes the next index to be used used for tagging with this secret.
-     * For this to work, the ivsk_m of the sender must be known.
-     * @param sender - The address sending the note
-     * @param recipient - The address receiving the note
-     * @returns A tagging secret that can be used to tag notes.
-     */
-    getIndexedTaggingSecretAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<IndexedTaggingSecret>;
-    syncPrivateState(pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;
-    deliverNote(contractAddress: AztecAddress, storageSlot: Fr, nonce: Fr, content: Fr[], noteHash: Fr, nullifier: Fr, txHash: TxHash, recipient: AztecAddress): Promise<void>;
-    getLogByTag(tag: Fr): Promise<LogWithTxData | null>;
-    storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void>;
-    loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
-    deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void>;
-    copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
-    aes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer>;
-    getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
-    storePrivateEventLog(contractAddress: AztecAddress, recipient: AztecAddress, eventSelector: EventSelector, msgContent: Fr[], txHash: TxHash, logIndexInTx: number, txIndexInBlock: number): Promise<void>;
-}
-//# sourceMappingURL=utility_execution_oracle.d.ts.map

package/dest/private/utility_execution_oracle.d.ts.map

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