@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/dest/private/acvm/serialize.js

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 /**
  * Adapts the buffer to the field size.
  * @param originalBuf - The buffer to adapt.
@@ -44,3 +44,56 @@ import { Fr } from '@aztec/foundation/fields';
         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 Logger, type LoggerBindings } from '@aztec/foundation/log';
+import type { ForeignCallHandler, WitnessMap } from '@aztec/noir-acvm_js';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/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,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

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":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAiB,MAAM,uBAAuB,CAAC;AAExF,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAKtE,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/{providers/acvm_native.js → acvm_native.js}

@@ -1,9 +1,8 @@
 import { runInDirectory } from '@aztec/foundation/fs';
-import { createLogger } from '@aztec/foundation/log';
+import { resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
-const logger = createLogger('simulator:acvm-native');
 export var ACVM_RESULT = /*#__PURE__*/ function(ACVM_RESULT) {
     ACVM_RESULT[ACVM_RESULT["SUCCESS"] = 0] = "SUCCESS";
     ACVM_RESULT[ACVM_RESULT["FAILURE"] = 1] = "FAILURE";
@@ -31,7 +30,8 @@ export var ACVM_RESULT = /*#__PURE__*/ function(ACVM_RESULT) {
  * @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) {
+ */ 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
@@ -42,7 +42,7 @@ export var ACVM_RESULT = /*#__PURE__*/ function(ACVM_RESULT) {
     try {
         // Check that the directory exists
         await fs.access(workingDirectory);
-    } catch (error) {
+    } catch  {
         return {
             status: 1,
             reason: `Working directory ${workingDirectory} does not exist`
@@ -67,41 +67,44 @@ export var ACVM_RESULT = /*#__PURE__*/ function(ACVM_RESULT) {
         ];
         logger.debug(`Calling ACVM with ${args.join(' ')}`);
         const processPromise = new Promise((resolve, reject)=>{
-            let outputWitness = Buffer.alloc(0);
-            let errorBuffer = Buffer.alloc(0);
+            const outChunks = [];
+            const errChunks = [];
+            let outLen = 0;
+            let errLen = 0;
             const acvm = proc.spawn(pathToAcvm, args);
             acvm.stdout.on('data', (data)=>{
-                outputWitness = Buffer.concat([
-                    outputWitness,
-                    data
-                ]);
+                outChunks.push(data);
+                outLen += data.length;
             });
             acvm.stderr.on('data', (data)=>{
-                errorBuffer = Buffer.concat([
-                    errorBuffer,
-                    data
-                ]);
+                errChunks.push(data);
+                errLen += data.length;
             });
             acvm.on('close', (code)=>{
                 if (code === 0) {
-                    resolve(outputWitness.toString('utf-8'));
+                    resolve(Buffer.concat(outChunks, outLen).toString('utf-8'));
                 } else {
-                    logger.error(`From ACVM: ${errorBuffer.toString('utf-8')}`);
-                    reject(errorBuffer.toString('utf-8'));
+                    const stderr = Buffer.concat(errChunks, errLen);
+                    logger.error(`From ACVM: ${stderr.toString('utf-8')}`);
+                    reject(stderr.toString('utf-8'));
                 }
             });
         });
-        const duration = new Timer();
+        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: duration.ms()
+            duration
         };
     } catch (error) {
         return {
@@ -114,26 +117,31 @@ export class NativeACVMSimulator {
     workingDirectory;
     pathToAcvm;
     witnessFilename;
-    constructor(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, compiledCircuit) {
+    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(compiledCircuit.bytecode, 'base64');
+            const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
             // Execute the circuit
-            const result = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm, this.witnessFilename);
+            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.witness;
+            return result;
         };
-        return await runInDirectory(this.workingDirectory, operation, false, logger);
+        return await runInDirectory(this.workingDirectory, operation, false, this.logger);
     }
-    executeUserCircuit(_acir, _initialWitness, _callback) {
+    executeUserCircuit(_input, _artifact, _callback) {
         throw new Error('Not implemented');
     }
 }

package/dest/private/acvm_wasm.d.ts

@@ -0,0 +1,16 @@
+import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
+import { type ForeignCallHandler } from '@aztec/noir-acvm_js';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN2bV93YXNtLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS9hY3ZtX3dhc20udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssY0FBYyxFQUFpQixNQUFNLHVCQUF1QixDQUFDO0FBRXhGLE9BQWlCLEVBQXVCLEtBQUssa0JBQWtCLEVBQWtCLE1BQU0scUJBQXFCLENBQUM7QUFFN0csT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMxRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXRFLE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBRSxLQUFLLG1CQUFtQixFQUFRLE1BQU0sZ0JBQWdCLENBQUM7QUFDbkYsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQW1CLE1BQU0sd0JBQXdCLENBQUM7QUFFaEYscUJBQWEsYUFBYyxZQUFXLGdCQUFnQjtJQUNwRCxTQUFTLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQztJQUV0QixZQUFZLGdCQUFnQixDQUFDLEVBQUUsTUFBTSxHQUFHLGNBQWMsRUFFckQ7SUFFSyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQVExQjtJQUVLLHNCQUFzQixDQUMxQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FDM0IsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQWdDdEI7SUFFSyxrQkFBa0IsQ0FDdEIsS0FBSyxFQUFFLFdBQVcsRUFDbEIsUUFBUSxFQUFFLGdDQUFnQyxFQUMxQyxRQUFRLEVBQUUsWUFBWSxHQUNyQixPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FHOUI7Q0FDRiJ9

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,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAiB,MAAM,uBAAuB,CAAC;AAExF,OAAiB,EAAuB,KAAK,kBAAkB,EAAkB,MAAM,qBAAqB,CAAC;AAE7G,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,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;AAEhF,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,CAQ1B;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,65 @@
+import { resolveLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import initACVM, { executeCircuit } from '@aztec/noir-acvm_js';
+import initAbi from '@aztec/noir-noirc_abi';
+import { acvm } from './acvm/acvm.js';
+import { enrichNoirError } from './circuit_simulator.js';
+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 */ await Promise.all([
+                initAbi(),
+                initACVM()
+            ]);
+        }
+    }
+    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/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN2bV93YXNtX3dpdGhfYmxvYnMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlL2Fjdm1fd2FzbV93aXRoX2Jsb2JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBdUIsS0FBSyxrQkFBa0IsRUFBa0IsTUFBTSxxQkFBcUIsQ0FBQztBQUNuRyxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzFFLE9BQU8sS0FBSyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFdEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQW1CLE1BQU0sd0JBQXdCLENBQUM7QUFFaEY7Ozs7OztHQU1HO0FBQ0gscUJBQWEsc0JBQXVCLFlBQVcsZ0JBQWdCO0lBQ3ZELHNCQUFzQixDQUMxQixLQUFLLEVBQUUsVUFBVSxFQUNqQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FDM0IsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQXFCdEI7SUFFRCxrQkFBa0IsQ0FDaEIsTUFBTSxFQUFFLFdBQVcsRUFDbkIsU0FBUyxFQUFFLGdDQUFnQyxFQUMzQyxTQUFTLEVBQUUsWUFBWSxHQUN0QixPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FFOUI7Q0FDRiJ9

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":"AACA,OAAO,EAAuB,KAAK,kBAAkB,EAAkB,MAAM,qBAAqB,CAAC;AACnG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,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,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 { Timer } from '@aztec/foundation/timer';
+import { executeCircuit } from '@aztec/noir-acvm_js';
+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_recording/circuit_recorder.d.ts

@@ -0,0 +1,109 @@
+import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
+import type { ForeignCallHandler } from '@aztec/noir-acvm_js';
+import type { ACIRCallback } from '../acvm/acvm.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
+export type OracleCall = {
+    name: string;
+    inputs: unknown[];
+    outputs: unknown;
+    time: number;
+    stackDepth: number;
+};
+export declare class CircuitRecording {
+    circuitName: string;
+    functionName: string;
+    bytecodeSHA512Hash: string;
+    timestamp: number;
+    inputs: Record<string, string>;
+    oracleCalls: OracleCall[];
+    error?: string;
+    parent?: CircuitRecording;
+    constructor(circuitName: string, functionName: string, bytecodeSHA512Hash: string, inputs: Record<string, string>);
+    setParent(recording?: CircuitRecording): void;
+}
+/**
+ * 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.
+ *
+ * Example recording object:
+ * ```json
+ * {
+ *   "circuitName": "AMM",
+ *   "functionName": "add_liquidity",
+ *   "bytecodeSHA512Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
+ *   "timestamp": 1740691464360,
+ *   "inputs": {
+ *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
+ *     "1": "0x00f4d59c0ff773427bb0fed5b422557ca4dc5655abe53d31fa9408cb3c5a672f",
+ *     "5": "0x000000000000000000000000000000000000000000000000000000000000000f"
+ *   },
+ *   "oracleCalls": [
+ *     {
+ *       "name": "loadCapsule",
+ *       "inputs": [
+ *         [
+ *           "0x102422483bad6abd385948435667e144ac4c272576e325e7563608876cd446fd"
+ *         ],
+ *         [
+ *           "0x000000000000000000000000000000000000000000000000000000000000004d"
+ *         ],
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000001"
+ *         ]
+ *       ],
+ *       "outputs": [
+ *         "0x0000000000000000000000000000000000000000000000000000000000000000",
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000000"
+ *         ]
+ *       ]
+ *     },
+ *     {
+ *       "name": "fetchTaggedLogs",
+ *       "inputs": []
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+export declare class CircuitRecorder {
+    #private;
+    protected readonly logger: Logger;
+    protected recording?: CircuitRecording;
+    private stackDepth;
+    private newCircuit;
+    protected constructor(loggerOrBindings?: Logger | LoggerBindings);
+    /**
+     * 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'.
+     */
+    start(input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName: string): Promise<void>;
+    /**
+     * 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: ACIRCallback | ForeignCallHandler | undefined): ACIRCallback | ForeignCallHandler | undefined;
+    /**
+     * 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
+     */
+    recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number): Promise<OracleCall>;
+    /**
+     * Finalizes the recording by resetting the state and returning the recording object.
+     */
+    finish(): Promise<CircuitRecording>;
+    /**
+     * Finalizes the recording by resetting the state and returning the recording object with an attached error.
+     * @param error - The error that occurred during circuit execution
+     */
+    finishWithError(error: unknown): Promise<CircuitRecording>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/private/circuit_recording/circuit_recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit_recorder.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/circuit_recorder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAiB,MAAM,uBAAuB,CAAC;AAExF,OAAO,KAAK,EAAE,kBAAkB,EAAuC,MAAM,qBAAqB,CAAC;AAEnG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IAMb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,qBAAa,gBAAgB;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAE1B,YAAY,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAOhH;IAED,SAAS,CAAC,SAAS,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAE5C;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,eAAe;;IAC1B,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAElC,SAAS,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAEvC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,UAAU,CAAiB;IAEnC,SAAS,aAAa,gBAAgB,CAAC,EAAE,MAAM,GAAG,cAAc,EAE/D;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAa3G;IAED;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,kBAAkB,GAAG,SAAS,GAAG,YAAY,GAAG,kBAAkB,GAAG,SAAS,CAQnH;IA6ED;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAUnH;IAED;;OAEG;IACH,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAclC;IAED;;;OAGG;IACG,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAI/D;CACF"}