@aztec-labs/simulator 6.0.0-nightly.20260829

package/dest/private/acvm/serialize.js

@@ -0,0 +1,99 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+/**
+ * Adapts the buffer to the field size.
+ * @param originalBuf - The buffer to adapt.
+ * @returns The adapted buffer.
+ */ function adaptBufferSize(originalBuf) {
+    const buffer = Buffer.alloc(Fr.SIZE_IN_BYTES);
+    if (originalBuf.length > buffer.length) {
+        throw new Error('Buffer does not fit in field');
+    }
+    originalBuf.copy(buffer, buffer.length - originalBuf.length);
+    return buffer;
+}
+/**
+ * Converts a value to an ACVM field.
+ * @param value - The value to convert.
+ * @returns The ACVM field.
+ */ export function toACVMField(value) {
+    let buffer;
+    if (Buffer.isBuffer(value)) {
+        buffer = value;
+    } else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+        buffer = new Fr(value).toBuffer();
+    } else if (typeof value === 'string') {
+        buffer = Fr.fromHexString(value).toBuffer();
+    } else {
+        buffer = value.toBuffer();
+    }
+    return `0x${adaptBufferSize(buffer).toString('hex')}`;
+}
+/**
+ * Converts a single value or an array of single values into the equivalent ACVM field representation.
+ */ export function toACVMFieldSingleOrArray(value) {
+    return Array.isArray(value) ? value.map(toACVMField) : toACVMField(value);
+}
+/**
+ * Inserts a list of ACVM fields to a witness.
+ * @param witnessStartIndex - The index where to start inserting the fields.
+ * @param fields - The fields to insert.
+ * @returns The witness.
+ */ export function toACVMWitness(witnessStartIndex, fields) {
+    return fields.reduce((witness, field, index)=>{
+        witness.set(index + witnessStartIndex, toACVMField(field));
+        return witness;
+    }, new Map());
+}
+export function bufferToU8Array(buffer) {
+    return Array.from(buffer).map((byte)=>toACVMField(BigInt(byte)));
+}
+export function bufferToBoundedVec(buffer, maxLen) {
+    const u8Array = bufferToU8Array(buffer);
+    return arrayToBoundedVec(u8Array, maxLen);
+}
+/**
+ * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
+ * If the input array is shorter than the maxLen, it pads the result with zeros,
+ * so that nr can correctly coerce this result into a BoundedVec.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */ export function arrayToBoundedVec(bVecStorage, maxLen) {
+    if (bVecStorage.length > maxLen) {
+        throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+    }
+    const lengthDiff = maxLen - bVecStorage.length;
+    const zeroPaddingArray = Array(lengthDiff).fill(toACVMField(BigInt(0)));
+    const storage = bVecStorage.concat(zeroPaddingArray);
+    const len = toACVMField(BigInt(bVecStorage.length));
+    return [
+        storage,
+        len
+    ];
+}
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */ export function arrayOfArraysToBoundedVecOfArrays(bVecStorage, maxLen, nestedArrayLength) {
+    if (bVecStorage.length > maxLen) {
+        throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+    }
+    // Check that all nested arrays have length nestedArrayLength
+    if (!bVecStorage.every((nestedArray)=>nestedArray.length === nestedArrayLength)) {
+        throw new Error(`Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`);
+    }
+    // Flatten the array of arrays
+    const flattenedStorage = bVecStorage.flat();
+    // Calculate and add padding
+    const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+    const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(toACVMField(BigInt(0))));
+    // Return flattened array with padding and length
+    const len = toACVMField(BigInt(bVecStorage.length));
+    return [
+        flattenedStorageWithPadding,
+        len
+    ];
+}

package/dest/private/acvm_native.d.ts

@@ -0,0 +1,41 @@
+import type { ForeignCallHandler, WitnessMap } from '@aztec/noir-acvm_js';
+import { type Logger, type LoggerBindings } from '@aztec-labs/foundation/log';
+import type { FunctionArtifactWithContractName } from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec-labs/stdlib/noir';
+import type { ACIRCallback, ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
+import type { CircuitSimulator } from './circuit_simulator.js';
+export declare enum ACVM_RESULT {
+    SUCCESS = 0,
+    FAILURE = 1
+}
+export type ACVMSuccess = {
+    status: ACVM_RESULT.SUCCESS;
+    duration: number;
+    witness: Map<number, string>;
+};
+export type ACVMFailure = {
+    status: ACVM_RESULT.FAILURE;
+    reason: string;
+};
+export type ACVMResult = ACVMSuccess | ACVMFailure;
+/**
+ *
+ * @param inputWitness - The circuit's input witness
+ * @param bytecode - The circuit bytecode
+ * @param workingDirectory - A directory to use for temporary files by the ACVM
+ * @param pathToAcvm - The path to the ACVM binary
+ * @param outputFilename - If specified, the output will be stored as a file, encoded using Bincode
+ * @returns The completed partial witness outputted from the circuit
+ */
+export declare function executeNativeCircuit(inputWitness: WitnessMap, bytecode: Buffer, workingDirectory: string, pathToAcvm: string, outputFilename?: string, loggerOrBindings?: Logger | LoggerBindings): Promise<ACVMResult>;
+export declare class NativeACVMSimulator implements CircuitSimulator {
+    private workingDirectory;
+    private pathToAcvm;
+    private witnessFilename?;
+    private logger;
+    constructor(workingDirectory: string, pathToAcvm: string, witnessFilename?: string | undefined, loggerOrBindings?: Logger | LoggerBindings);
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler | undefined): Promise<ACVMSuccess>;
+    executeUserCircuit(_input: ACVMWitness, _artifact: FunctionArtifactWithContractName, _callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN2bV9uYXRpdmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlL2Fjdm1fbmF0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLFVBQVUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRzFFLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBRSxLQUFLLGNBQWMsRUFBaUIsTUFBTSw0QkFBNEIsQ0FBQztBQUU3RixPQUFPLEtBQUssRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQy9FLE9BQU8sS0FBSyxFQUFFLDJCQUEyQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFJM0UsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUvRCxvQkFBWSxXQUFXO0lBQ3JCLE9BQU8sSUFBQTtJQUNQLE9BQU8sSUFBQTtDQUNSO0FBRUQsTUFBTSxNQUFNLFdBQVcsR0FBRztJQUN4QixNQUFNLEVBQUUsV0FBVyxDQUFDLE9BQU8sQ0FBQztJQUM1QixRQUFRLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLE9BQU8sRUFBRSxHQUFHLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0NBQzlCLENBQUM7QUFFRixNQUFNLE1BQU0sV0FBVyxHQUFHO0lBQ3hCLE1BQU0sRUFBRSxXQUFXLENBQUMsT0FBTyxDQUFDO0lBQzVCLE1BQU0sRUFBRSxNQUFNLENBQUM7Q0FDaEIsQ0FBQztBQUVGLE1BQU0sTUFBTSxVQUFVLEdBQUcsV0FBVyxHQUFHLFdBQVcsQ0FBQztBQW1CbkQ7Ozs7Ozs7O0dBUUc7QUFDSCx3QkFBc0Isb0JBQW9CLENBQ3hDLFlBQVksRUFBRSxVQUFVLEVBQ3hCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLGdCQUFnQixFQUFFLE1BQU0sRUFDeEIsVUFBVSxFQUFFLE1BQU0sRUFDbEIsY0FBYyxDQUFDLEVBQUUsTUFBTSxFQUN2QixnQkFBZ0IsQ0FBQyxFQUFFLE1BQU0sR0FBRyxjQUFjLEdBQ3pDLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0ErRXJCO0FBRUQscUJBQWEsbUJBQW9CLFlBQVcsZ0JBQWdCO0lBSXhELE9BQU8sQ0FBQyxnQkFBZ0I7SUFDeEIsT0FBTyxDQUFDLFVBQVU7SUFDbEIsT0FBTyxDQUFDLGVBQWUsQ0FBQztJQUwxQixPQUFPLENBQUMsTUFBTSxDQUFTO0lBRXZCLFlBQ1UsZ0JBQWdCLEVBQUUsTUFBTSxFQUN4QixVQUFVLEVBQUUsTUFBTSxFQUNsQixlQUFlLENBQUMsb0JBQVEsRUFDaEMsZ0JBQWdCLENBQUMsRUFBRSxNQUFNLEdBQUcsY0FBYyxFQUczQztJQUVLLHNCQUFzQixDQUMxQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FBRyxTQUFTLEdBQ3ZDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0E0QnRCO0lBRUQsa0JBQWtCLENBQ2hCLE1BQU0sRUFBRSxXQUFXLEVBQ25CLFNBQVMsRUFBRSxnQ0FBZ0MsRUFDM0MsU0FBUyxFQUFFLFlBQVksR0FDdEIsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBRTlCO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_native.d.ts","sourceRoot":"","sources":["../../src/private/acvm_native.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG1E,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAiB,MAAM,4BAA4B,CAAC;AAE7F,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAC/E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAI3E,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,oBAAY,WAAW;IACrB,OAAO,IAAA;IACP,OAAO,IAAA;CACR;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAmBnD;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,UAAU,EACxB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,EACvB,gBAAgB,CAAC,EAAE,MAAM,GAAG,cAAc,GACzC,OAAO,CAAC,UAAU,CAAC,CA+ErB;AAED,qBAAa,mBAAoB,YAAW,gBAAgB;IAIxD,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,eAAe,CAAC;IAL1B,OAAO,CAAC,MAAM,CAAS;IAEvB,YACU,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,eAAe,CAAC,oBAAQ,EAChC,gBAAgB,CAAC,EAAE,MAAM,GAAG,cAAc,EAG3C;IAEK,sBAAsB,CAC1B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC,CA4BtB;IAED,kBAAkB,CAChB,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,gCAAgC,EAC3C,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,mBAAmB,CAAC,CAE9B;CACF"}

package/dest/private/acvm_native.js

@@ -0,0 +1,147 @@
+import { runInDirectory } from '@aztec-labs/foundation/fs';
+import { resolveLogger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import * as proc from 'child_process';
+import { promises as fs } from 'fs';
+export var ACVM_RESULT = /*#__PURE__*/ function(ACVM_RESULT) {
+    ACVM_RESULT[ACVM_RESULT["SUCCESS"] = 0] = "SUCCESS";
+    ACVM_RESULT[ACVM_RESULT["FAILURE"] = 1] = "FAILURE";
+    return ACVM_RESULT;
+}({});
+/**
+ * Parses a TOML format witness map string into a Map structure
+ * @param outputString - The witness map in TOML format
+ * @returns The parsed witness map
+ */ function parseIntoWitnessMap(outputString) {
+    const lines = outputString.split('\n');
+    return new Map(lines.filter((line)=>line.length).map((line)=>{
+        const pair = line.replaceAll(' ', '').split('=');
+        return [
+            Number(pair[0]),
+            pair[1].replaceAll('"', '')
+        ];
+    }));
+}
+/**
+ *
+ * @param inputWitness - The circuit's input witness
+ * @param bytecode - The circuit bytecode
+ * @param workingDirectory - A directory to use for temporary files by the ACVM
+ * @param pathToAcvm - The path to the ACVM binary
+ * @param outputFilename - If specified, the output will be stored as a file, encoded using Bincode
+ * @returns The completed partial witness outputted from the circuit
+ */ export async function executeNativeCircuit(inputWitness, bytecode, workingDirectory, pathToAcvm, outputFilename, loggerOrBindings) {
+    const logger = resolveLogger('simulator:acvm-native', loggerOrBindings);
+    const bytecodeFilename = 'bytecode';
+    const witnessFilename = 'input_witness.toml';
+    // convert the witness map to TOML format
+    let witnessMap = '';
+    inputWitness.forEach((value, key)=>{
+        witnessMap = witnessMap.concat(`${key} = '${value}'\n`);
+    });
+    try {
+        // Check that the directory exists
+        await fs.access(workingDirectory);
+    } catch  {
+        return {
+            status: 1,
+            reason: `Working directory ${workingDirectory} does not exist`
+        };
+    }
+    try {
+        // Write the bytecode and input witness to the working directory
+        await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
+        await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
+        // Execute the ACVM using the given args
+        const args = [
+            `execute`,
+            `--working-directory`,
+            `${workingDirectory}`,
+            `--bytecode`,
+            `${bytecodeFilename}`,
+            `--input-witness`,
+            `${witnessFilename}`,
+            '--print',
+            '--output-witness',
+            'output-witness'
+        ];
+        logger.debug(`Calling ACVM with ${args.join(' ')}`);
+        const processPromise = new Promise((resolve, reject)=>{
+            const outChunks = [];
+            const errChunks = [];
+            let outLen = 0;
+            let errLen = 0;
+            const acvm = proc.spawn(pathToAcvm, args);
+            acvm.stdout.on('data', (data)=>{
+                outChunks.push(data);
+                outLen += data.length;
+            });
+            acvm.stderr.on('data', (data)=>{
+                errChunks.push(data);
+                errLen += data.length;
+            });
+            acvm.on('close', (code)=>{
+                if (code === 0) {
+                    resolve(Buffer.concat(outChunks, outLen).toString('utf-8'));
+                } else {
+                    const stderr = Buffer.concat(errChunks, errLen);
+                    logger.error(`From ACVM: ${stderr.toString('utf-8')}`);
+                    reject(stderr.toString('utf-8'));
+                }
+            });
+        });
+        const timer = new Timer();
+        const output = await processPromise;
+        const duration = timer.ms();
+        if (outputFilename) {
+            const outputWitnessFileName = `${workingDirectory}/output-witness.gz`;
+            await fs.copyFile(outputWitnessFileName, outputFilename);
+        }
+        // TODO: We shouldn't be parsing the witness from stdout, it's not very performant, and we end up with two ways of fetching the witness.
+        // We probably should implement the WitnessStack type, run the ACVM with msgpack serialization mode (env variable), and ungzip and parse the witness from
+        // the outputted gz witness file.
+        const witness = parseIntoWitnessMap(output);
+        return {
+            status: 0,
+            witness,
+            duration
+        };
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `${error}`
+        };
+    }
+}
+export class NativeACVMSimulator {
+    workingDirectory;
+    pathToAcvm;
+    witnessFilename;
+    logger;
+    constructor(workingDirectory, pathToAcvm, witnessFilename, loggerOrBindings){
+        this.workingDirectory = workingDirectory;
+        this.pathToAcvm = pathToAcvm;
+        this.witnessFilename = witnessFilename;
+        this.logger = resolveLogger('simulator:acvm-native', loggerOrBindings);
+    }
+    async executeProtocolCircuit(input, artifact, callback) {
+        // Execute the circuit on those initial witness values
+        if (callback) {
+            throw new Error('Native ACVM simulator does not support foreign calls. Ignoring callback.');
+        }
+        const operation = async (directory)=>{
+            // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+            const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
+            // Execute the circuit
+            const result = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm, this.witnessFilename, this.logger);
+            if (result.status == 1) {
+                throw new Error(`Failed to generate witness: ${result.reason}`);
+            }
+            return result;
+        };
+        return await runInDirectory(this.workingDirectory, operation, false, this.logger);
+    }
+    executeUserCircuit(_input, _artifact, _callback) {
+        throw new Error('Not implemented');
+    }
+}

package/dest/private/acvm_wasm.d.ts

@@ -0,0 +1,16 @@
+import { type ForeignCallHandler } from '@aztec/noir-acvm_js';
+import { type Logger, type LoggerBindings } from '@aztec-labs/foundation/log';
+import type { FunctionArtifactWithContractName } from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec-labs/stdlib/noir';
+import { type ACIRCallback, type ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
+import { type CircuitSimulator } from './circuit_simulator.js';
+export declare class WASMSimulator implements CircuitSimulator {
+    protected log: Logger;
+    constructor(loggerOrBindings?: Logger | LoggerBindings);
+    init(): Promise<void>;
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler): Promise<ACVMSuccess>;
+    executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN2bV93YXNtLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS9hY3ZtX3dhc20udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBaUIsRUFBdUIsS0FBSyxrQkFBa0IsRUFBa0IsTUFBTSxxQkFBcUIsQ0FBQztBQUc3RyxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQUUsS0FBSyxjQUFjLEVBQWlCLE1BQU0sNEJBQTRCLENBQUM7QUFFN0YsT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMvRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRTNFLE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBRSxLQUFLLG1CQUFtQixFQUFRLE1BQU0sZ0JBQWdCLENBQUM7QUFDbkYsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQW1CLE1BQU0sd0JBQXdCLENBQUM7QUFJaEYscUJBQWEsYUFBYyxZQUFXLGdCQUFnQjtJQUNwRCxTQUFTLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQztJQUV0QixZQUFZLGdCQUFnQixDQUFDLEVBQUUsTUFBTSxHQUFHLGNBQWMsRUFFckQ7SUFFSyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQVMxQjtJQUVLLHNCQUFzQixDQUMxQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FDM0IsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQWdDdEI7SUFFSyxrQkFBa0IsQ0FDdEIsS0FBSyxFQUFFLFdBQVcsRUFDbEIsUUFBUSxFQUFFLGdDQUFnQyxFQUMxQyxRQUFRLEVBQUUsWUFBWSxHQUNyQixPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FHOUI7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_wasm.d.ts","sourceRoot":"","sources":["../../src/private/acvm_wasm.ts"],"names":[],"mappings":"AAAA,OAAiB,EAAuB,KAAK,kBAAkB,EAAkB,MAAM,qBAAqB,CAAC;AAG7G,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAiB,MAAM,4BAA4B,CAAC;AAE7F,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAC/E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAE3E,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAQ,MAAM,gBAAgB,CAAC;AACnF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAmB,MAAM,wBAAwB,CAAC;AAIhF,qBAAa,aAAc,YAAW,gBAAgB;IACpD,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;IAEtB,YAAY,gBAAgB,CAAC,EAAE,MAAM,GAAG,cAAc,EAErD;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAS1B;IAEK,sBAAsB,CAC1B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC,CAgCtB;IAEK,kBAAkB,CACtB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAG9B;CACF"}

package/dest/private/acvm_wasm.js

@@ -0,0 +1,67 @@
+import initACVM, { executeCircuit } from '@aztec/noir-acvm_js';
+import initAbi from '@aztec/noir-noirc_abi';
+import { resolveLogger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { acvm } from './acvm/acvm.js';
+import { enrichNoirError } from './circuit_simulator.js';
+let wasmInitPromise;
+export class WASMSimulator {
+    log;
+    constructor(loggerOrBindings){
+        this.log = resolveLogger('wasm-simulator', loggerOrBindings);
+    }
+    async init() {
+        // If these are available, then we are in the
+        // web environment. For the node environment, this
+        // is a no-op.
+        if (typeof initAbi === 'function') {
+            /** @ts-expect-error The node bundle doesn't include these default imports, so TS complains */ wasmInitPromise ??= Promise.all([
+                initAbi(),
+                initACVM()
+            ]);
+            await wasmInitPromise;
+        }
+    }
+    async executeProtocolCircuit(input, artifact, callback) {
+        this.log.debug('init', {
+            hash: artifact.hash
+        });
+        await this.init();
+        // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+        const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
+        //
+        // Execute the circuit
+        try {
+            const timer = new Timer();
+            const result = await executeCircuit(decodedBytecode, input, callback);
+            this.log.debug('execution successful', {
+                hash: artifact.hash
+            });
+            return {
+                witness: result,
+                duration: timer.ms()
+            };
+        } catch (err) {
+            // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
+            // assertion payload.
+            if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+                const parsed = enrichNoirError(artifact, err);
+                this.log.debug('execution failed', {
+                    hash: artifact.hash,
+                    error: parsed,
+                    message: parsed.message
+                });
+                throw parsed;
+            }
+            this.log.debug('execution failed', {
+                hash: artifact.hash,
+                error: err
+            });
+            throw new Error(`Circuit execution failed: ${err}`);
+        }
+    }
+    async executeUserCircuit(input, artifact, callback) {
+        await this.init();
+        return acvm(artifact.bytecode, input, callback, this.log.createChild('acvm'));
+    }
+}

package/dest/private/acvm_wasm_with_blobs.d.ts

@@ -0,0 +1,20 @@
+import { type ForeignCallHandler } from '@aztec/noir-acvm_js';
+import type { WitnessMap } from '@aztec/noir-types';
+import type { FunctionArtifactWithContractName } from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec-labs/stdlib/noir';
+import type { ACIRCallback, ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
+import { type CircuitSimulator } from './circuit_simulator.js';
+/**
+ * A circuit simulator that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
+ * This class is temporary while brillig cannot handle the blob math, and it is kept separate
+ * because the zkg commitment library used in the blob code is not browser compatible.
+ *
+ * It is only used in the context of server-side code executing simulated protocol circuits.
+ */
+export declare class WASMSimulatorWithBlobs implements CircuitSimulator {
+    executeProtocolCircuit(input: WitnessMap, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler): Promise<ACVMSuccess>;
+    executeUserCircuit(_input: ACVMWitness, _artifact: FunctionArtifactWithContractName, _callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN2bV93YXNtX3dpdGhfYmxvYnMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlL2Fjdm1fd2FzbV93aXRoX2Jsb2JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBdUIsS0FBSyxrQkFBa0IsRUFBa0IsTUFBTSxxQkFBcUIsQ0FBQztBQUNuRyxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUdwRCxPQUFPLEtBQUssRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQy9FLE9BQU8sS0FBSyxFQUFFLDJCQUEyQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFM0UsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQW1CLE1BQU0sd0JBQXdCLENBQUM7QUFFaEY7Ozs7OztHQU1HO0FBQ0gscUJBQWEsc0JBQXVCLFlBQVcsZ0JBQWdCO0lBQ3ZELHNCQUFzQixDQUMxQixLQUFLLEVBQUUsVUFBVSxFQUNqQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FDM0IsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQXFCdEI7SUFFRCxrQkFBa0IsQ0FDaEIsTUFBTSxFQUFFLFdBQVcsRUFDbkIsU0FBUyxFQUFFLGdDQUFnQyxFQUMzQyxTQUFTLEVBQUUsWUFBWSxHQUN0QixPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FFOUI7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_wasm_with_blobs.d.ts","sourceRoot":"","sources":["../../src/private/acvm_wasm_with_blobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,kBAAkB,EAAkB,MAAM,qBAAqB,CAAC;AACnG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAC/E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAE3E,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAmB,MAAM,wBAAwB,CAAC;AAEhF;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,gBAAgB;IACvD,sBAAsB,CAC1B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC,CAqBtB;IAED,kBAAkB,CAChB,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,gCAAgC,EAC3C,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,mBAAmB,CAAC,CAE9B;CACF"}

package/dest/private/acvm_wasm_with_blobs.js

@@ -0,0 +1,35 @@
+import { executeCircuit } from '@aztec/noir-acvm_js';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { enrichNoirError } from './circuit_simulator.js';
+/**
+ * A circuit simulator that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
+ * This class is temporary while brillig cannot handle the blob math, and it is kept separate
+ * because the zkg commitment library used in the blob code is not browser compatible.
+ *
+ * It is only used in the context of server-side code executing simulated protocol circuits.
+ */ export class WASMSimulatorWithBlobs {
+    async executeProtocolCircuit(input, artifact, callback) {
+        // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+        const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
+        //
+        // Execute the circuit
+        try {
+            const timer = new Timer();
+            const _witnessMap = await executeCircuit(decodedBytecode, input, callback);
+            return {
+                witness: _witnessMap,
+                duration: timer.ms()
+            };
+        } catch (err) {
+            // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
+            // assertion payload.
+            if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+                throw enrichNoirError(artifact, err);
+            }
+            throw new Error(`Circuit execution failed: ${err}`);
+        }
+    }
+    executeUserCircuit(_input, _artifact, _callback) {
+        throw new Error('Not implemented');
+    }
+}

package/dest/private/circuit_simulator.d.ts

@@ -0,0 +1,35 @@
+import type { ExecutionError, ForeignCallHandler } from '@aztec/noir-acvm_js';
+import type { FunctionArtifactWithContractName } from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledCircuit, NoirCompiledCircuitWithName } from '@aztec-labs/stdlib/noir';
+import { type ACIRCallback, type ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
+/**
+ * Low level simulation interface
+ */
+export interface CircuitSimulator {
+    /**
+     * Execute a protocol circuit/generate a witness
+     * @param input - The initial witness map defining all of the inputs to `circuit`.
+     * @param artifact - ACIR circuit bytecode and its metadata.
+     * @param callback - A callback to process any foreign calls from the circuit. Can be undefined as for native
+     * ACVM simulator we don't process foreign calls.
+     * @returns The solved witness calculated by executing the circuit on the provided inputs.
+     */
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler | undefined): Promise<ACVMSuccess>;
+    /**
+     * Execute a user circuit (smart contract function)/generate a witness
+     * @param input - The initial witness map defining all of the inputs to `circuit`.
+     * @param artifact - Contract function ACIR circuit bytecode and its metadata.
+     * @param callback - A callback to process any foreign calls from the circuit.
+     * @returns The solved witness calculated by executing the circuit on the provided inputs, as well as the return
+     * witness indices as specified by the circuit.
+     */
+    executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+export type DecodedError = ExecutionError & {
+    decodedAssertionPayload?: any;
+    noirCallStack?: string[];
+};
+export declare function enrichNoirError(artifact: NoirCompiledCircuit, originalError: ExecutionError): DecodedError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2lyY3VpdF9zaW11bGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlL2NpcmN1aXRfc2ltdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBSTlFLE9BQU8sS0FBSyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDL0UsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVoRyxPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQUUsS0FBSyxtQkFBbUIsRUFBb0IsTUFBTSxnQkFBZ0IsQ0FBQztBQUMvRixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVwRDs7R0FFRztBQUNILE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0I7Ozs7Ozs7T0FPRztJQUNILHNCQUFzQixDQUNwQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FBRyxTQUFTLEdBQ3ZDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUV4Qjs7Ozs7OztPQU9HO0lBQ0gsa0JBQWtCLENBQ2hCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLFFBQVEsRUFBRSxnQ0FBZ0MsRUFDMUMsUUFBUSxFQUFFLFlBQVksR0FDckIsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUM7Q0FDakM7QUFFRCxNQUFNLE1BQU0sWUFBWSxHQUFHLGNBQWMsR0FBRztJQUFFLHVCQUF1QixDQUFDLEVBQUUsR0FBRyxDQUFDO0lBQUMsYUFBYSxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUE7Q0FBRSxDQUFDO0FBSXhHLHdCQUFnQixlQUFlLENBQUMsUUFBUSxFQUFFLG1CQUFtQixFQUFFLGFBQWEsRUFBRSxjQUFjLEdBQUcsWUFBWSxDQTBDMUcifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"circuit_simulator.d.ts","sourceRoot":"","sources":["../../src/private/circuit_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAI9E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAC/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEhG,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAoB,MAAM,gBAAgB,CAAC;AAC/F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;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/circuit_simulator.js

@@ -0,0 +1,43 @@
+import { abiDecodeError } from '@aztec/noir-noirc_abi';
+import { parseDebugSymbols } from '@aztec-labs/stdlib/abi';
+import { extractCallStack } from './acvm/acvm.js';
+// Payload parsing taken from noir/noir-repo/tooling/noir_js/src/witness_generation.ts.
+// TODO: import this in isolation without having to import noir_js in its entirety.
+export function enrichNoirError(artifact, originalError) {
+    const enrichedError = originalError;
+    if (originalError.rawAssertionPayload) {
+        try {
+            // Decode the payload
+            const decodedPayload = abiDecodeError(artifact.abi, originalError.rawAssertionPayload);
+            if (typeof decodedPayload === 'string') {
+                // If it's a string, just add it to the error message
+                enrichedError.message = `Circuit execution failed: ${decodedPayload}`;
+            } else {
+                // If not, attach the payload to the original error
+                enrichedError.decodedAssertionPayload = decodedPayload;
+            }
+        } catch  {
+        // Ignore errors decoding the payload
+        }
+    }
+    try {
+        // Decode the callstack
+        const callStack = extractCallStack(originalError, {
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
+            // We only support handling debug info for the circuit entry point.
+            // So for now we simply index into the first debug info.
+            debugSymbols: parseDebugSymbols(artifact.debug_symbols)[0],
+            files: artifact.file_map
+        });
+        enrichedError.noirCallStack = callStack?.map((errorLocation)=>{
+            if (typeof errorLocation === 'string') {
+                return `at opcode ${errorLocation}`;
+            } else {
+                return `at ${errorLocation.locationText} (${errorLocation.filePath}:${errorLocation.line}:${errorLocation.column})`;
+            }
+        });
+    } catch  {
+    // Ignore errors resolving the callstack
+    }
+    return enrichedError;
+}

package/dest/private/factory.d.ts

@@ -0,0 +1,12 @@
+import { type Logger, type LoggerBindings } from '@aztec-labs/foundation/log';
+import type { CircuitSimulator } from './circuit_simulator.js';
+export type SimulatorConfig = {
+    acvmBinaryPath?: string;
+    acvmWorkingDirectory?: string;
+};
+export declare function getSimulatorConfigFromEnv(): {
+    acvmWorkingDirectory: string | undefined;
+    acvmBinaryPath: string | undefined;
+};
+export declare function createSimulator(config: SimulatorConfig, loggerOrBindings?: Logger | LoggerBindings): Promise<CircuitSimulator>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ByaXZhdGUvZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQUUsS0FBSyxjQUFjLEVBQWlCLE1BQU0sNEJBQTRCLENBQUM7QUFLN0YsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUvRCxNQUFNLE1BQU0sZUFBZSxHQUFHO0lBQzVCLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN4QixvQkFBb0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUMvQixDQUFDO0FBRUYsd0JBQWdCLHlCQUF5Qjs7O0VBTXhDO0FBRUQsd0JBQXNCLGVBQWUsQ0FDbkMsTUFBTSxFQUFFLGVBQWUsRUFDdkIsZ0JBQWdCLENBQUMsRUFBRSxNQUFNLEdBQUcsY0FBYyxHQUN6QyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FnQjNCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/private/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAiB,MAAM,4BAA4B,CAAC;AAK7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAgB,yBAAyB;;;EAMxC;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,eAAe,EACvB,gBAAgB,CAAC,EAAE,MAAM,GAAG,cAAc,GACzC,OAAO,CAAC,gBAAgB,CAAC,CAgB3B"}

package/dest/private/factory.js

@@ -0,0 +1,30 @@
+import { resolveLogger } from '@aztec-labs/foundation/log';
+import { promises as fs } from 'fs';
+import { NativeACVMSimulator } from './acvm_native.js';
+import { WASMSimulator } from './acvm_wasm.js';
+export function getSimulatorConfigFromEnv() {
+    const { ACVM_BINARY_PATH, ACVM_WORKING_DIRECTORY } = process.env;
+    return {
+        acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
+        acvmBinaryPath: ACVM_BINARY_PATH ? ACVM_BINARY_PATH : undefined
+    };
+}
+export async function createSimulator(config, loggerOrBindings) {
+    const logger = resolveLogger('simulator', loggerOrBindings);
+    if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
+        try {
+            await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
+            await fs.mkdir(config.acvmWorkingDirectory, {
+                recursive: true
+            });
+            logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
+            const acvmLogger = logger.createChild('acvm-native');
+            return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, acvmLogger);
+        } catch  {
+            logger.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
+        }
+    }
+    logger.info('Using WASM ACVM simulation');
+    const wasmLogger = logger.createChild('wasm');
+    return new WASMSimulator(wasmLogger);
+}

package/dest/public/avm/testing/account_proof_fetcher.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9wcm9vZl9mZXRjaGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHVibGljL2F2bS90ZXN0aW5nL2FjY291bnRfcHJvb2ZfZmV0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/public/avm/testing/account_proof_fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account_proof_fetcher.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/testing/account_proof_fetcher.ts"],"names":[],"mappings":""}