@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/private/hashed_values_cache.js

@@ -0,0 +1,46 @@
+import { Fr } from '@aztec/foundation/fields';
+import { HashedValues } from '@aztec/stdlib/tx';
+/**
+ * A cache for hashed values (arguments, returns) during transaction execution.
+ */ export class HashedValuesCache {
+    cache;
+    constructor(initialArguments = []){
+        this.cache = new Map();
+        for (const initialArg of initialArguments){
+            this.cache.set(initialArg.hash.toBigInt(), initialArg.values);
+        }
+    }
+    /**
+   * Creates a new hashed values cache.
+   * @param initialArguments - The initial arguments to add to the cache.
+   * @returns The new hashed values cache.
+   */ static create(initialArguments = []) {
+        return new HashedValuesCache(initialArguments);
+    }
+    /**
+   * Gets preimage of a hash.
+   * @param hash - The hash to get the preimage of.
+   * @returns The preimage.
+   */ getPreimage(hash) {
+        if (hash.equals(Fr.ZERO)) {
+            return [];
+        }
+        const hashedValues = this.cache.get(hash.toBigInt());
+        if (!hashedValues) {
+            throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
+        }
+        return hashedValues;
+    }
+    /**
+   * Stores values in cache and returns its hash.
+   * @param values - The values to store.
+   * @returns The hash of the values.
+   */ async store(values) {
+        if (values.length === 0) {
+            return Fr.ZERO;
+        }
+        const hashedValues = await HashedValues.fromValues(values);
+        this.cache.set(hashedValues.hash.toBigInt(), hashedValues.values);
+        return hashedValues.hash;
+    }
+}

package/dest/private/index.d.ts

@@ -0,0 +1,13 @@
+export { AcirSimulator } from './simulator.js';
+export { ViewDataOracle } from './view_data_oracle.js';
+export { type DBOracle, ContractClassNotFoundError, ContractNotFoundError } from './db_oracle.js';
+export * from './pick_notes.js';
+export { ExecutionNoteCache } from './execution_note_cache.js';
+export { extractPrivateCircuitPublicInputs, readCurrentClassId } from './private_execution.js';
+export { witnessMapToFields } from './acvm/deserialize.js';
+export { toACVMWitness } from './acvm/serialize.js';
+export { extractCallStack } from './acvm/acvm.js';
+export { type NoteData, TypedOracle } from './acvm/oracle/typed_oracle.js';
+export { Oracle } from './acvm/oracle/oracle.js';
+export { HashedValuesCache } from './hashed_values_cache.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/private/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,KAAK,QAAQ,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAClG,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,iCAAiC,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,KAAK,QAAQ,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC"}

package/dest/private/index.js

@@ -0,0 +1,12 @@
+export { AcirSimulator } from './simulator.js';
+export { ViewDataOracle } from './view_data_oracle.js';
+export { ContractClassNotFoundError, ContractNotFoundError } from './db_oracle.js';
+export * from './pick_notes.js';
+export { ExecutionNoteCache } from './execution_note_cache.js';
+export { extractPrivateCircuitPublicInputs, readCurrentClassId } from './private_execution.js';
+export { witnessMapToFields } from './acvm/deserialize.js';
+export { toACVMWitness } from './acvm/serialize.js';
+export { extractCallStack } from './acvm/acvm.js';
+export { TypedOracle } from './acvm/oracle/typed_oracle.js';
+export { Oracle } from './acvm/oracle/oracle.js';
+export { HashedValuesCache } from './hashed_values_cache.js';

package/dest/{client → private}/pick_notes.d.ts

@@ -1,5 +1,5 @@
-import { Comparator, type Note } from '@aztec/circuit-types';
 import { Fr } from '@aztec/foundation/fields';
+import { Comparator, type Note } from '@aztec/stdlib/note';
 export interface PropertySelector {
     index: number;
     offset: number;

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

@@ -0,0 +1 @@
+{"version":3,"file":"pick_notes.d.ts","sourceRoot":"","sources":["../../src/private/pick_notes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;OAEG;IACH,QAAQ,EAAE,gBAAgB,CAAC;IAC3B;;OAEG;IACH,KAAK,EAAE,EAAE,CAAC;IACV;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,oBAAY,SAAS;IACnB,IAAI,IAAI;IACR,IAAI,IAAI;IACR,GAAG,IAAI;CACR;AAED;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB;;OAEG;IACH,QAAQ,EAAE,gBAAgB,CAAC;IAC3B;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;CAClB;AAED;;GAEG;AACH,UAAU,UAAU;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,UAAU,YAAY;IACpB;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;CACZ;AA8CD;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,YAAY,EAC9C,SAAS,EAAE,CAAC,EAAE,EACd,EAAE,OAAY,EAAE,KAAU,EAAE,KAAS,EAAE,MAAU,EAAE,EAAE,UAAU,GAC9D,CAAC,EAAE,CAIL"}

package/dest/private/pick_notes.js

@@ -0,0 +1,51 @@
+import { Fr } from '@aztec/foundation/fields';
+import { Comparator } from '@aztec/stdlib/note';
+/**
+ * The order to sort an array.
+ */ export var SortOrder = /*#__PURE__*/ function(SortOrder) {
+    SortOrder[SortOrder["NADA"] = 0] = "NADA";
+    SortOrder[SortOrder["DESC"] = 1] = "DESC";
+    SortOrder[SortOrder["ASC"] = 2] = "ASC";
+    return SortOrder;
+}({});
+const selectPropertyFromPackedNoteContent = (noteData, selector)=>{
+    const noteValueBuffer = noteData[selector.index].toBuffer();
+    const noteValue = noteValueBuffer.subarray(selector.offset, selector.offset + selector.length);
+    return Fr.fromBuffer(noteValue);
+};
+const selectNotes = (noteDatas, selects)=>noteDatas.filter((noteData)=>selects.every(({ selector, value, comparator })=>{
+            const noteValueFr = selectPropertyFromPackedNoteContent(noteData.note.items, selector);
+            const comparatorSelector = {
+                [Comparator.EQ]: ()=>noteValueFr.equals(value),
+                [Comparator.NEQ]: ()=>!noteValueFr.equals(value),
+                [Comparator.LT]: ()=>noteValueFr.lt(value),
+                [Comparator.LTE]: ()=>noteValueFr.lt(value) || noteValueFr.equals(value),
+                [Comparator.GT]: ()=>!noteValueFr.lt(value) && !noteValueFr.equals(value),
+                [Comparator.GTE]: ()=>!noteValueFr.lt(value)
+            };
+            return comparatorSelector[comparator]();
+        }));
+const sortNotes = (a, b, sorts, level = 0)=>{
+    if (sorts[level] === undefined) {
+        return 0;
+    }
+    const { selector, order } = sorts[level];
+    if (order === 0) {
+        return 0;
+    }
+    const aValue = selectPropertyFromPackedNoteContent(a, selector);
+    const bValue = selectPropertyFromPackedNoteContent(b, selector);
+    const dir = order === 1 ? [
+        -1,
+        1
+    ] : [
+        1,
+        -1
+    ];
+    return aValue.toBigInt() === bValue.toBigInt() ? sortNotes(a, b, sorts, level + 1) : aValue.toBigInt() > bValue.toBigInt() ? dir[0] : dir[1];
+};
+/**
+ * Pick from a note array a number of notes that meet the criteria.
+ */ export function pickNotes(noteDatas, { selects = [], sorts = [], limit = 0, offset = 0 }) {
+    return selectNotes(noteDatas, selects).sort((a, b)=>sortNotes(a.note.items, b.note.items, sorts)).slice(offset, limit ? offset + limit : undefined);
+}

package/dest/private/private_execution.d.ts

@@ -0,0 +1,24 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type FunctionArtifact, type FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstance } from '@aztec/stdlib/contract';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+import { type ACVMWitness } from './acvm/index.js';
+import type { ClientExecutionContext } from './client_execution_context.js';
+import type { SimulationProvider } from './providers/simulation_provider.js';
+/**
+ * Execute a private function and return the execution result.
+ */
+export declare function executePrivateFunction(simulator: SimulationProvider, context: ClientExecutionContext, artifact: FunctionArtifact, contractAddress: AztecAddress, functionSelector: FunctionSelector, log?: import("@aztec/foundation/log").Logger): Promise<PrivateCallExecutionResult>;
+/**
+ * Get the private circuit public inputs from the partial witness.
+ * @param artifact - The function artifact
+ * @param partialWitness - The partial witness, result of simulating the function.
+ * @returns - The public inputs.
+ */
+export declare function extractPrivateCircuitPublicInputs(artifact: FunctionArtifact, partialWitness: ACVMWitness): PrivateCircuitPublicInputs;
+export declare function readCurrentClassId(contractAddress: AztecAddress, instance: ContractInstance, node: AztecNode, blockNumber: number): Promise<Fr>;
+export declare function verifyCurrentClassId(contractAddress: AztecAddress, instance: ContractInstance, node: AztecNode, blockNumber: number): Promise<void>;
+//# sourceMappingURL=private_execution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"private_execution.d.ts","sourceRoot":"","sources":["../../src/private/private_execution.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAsB,MAAM,mBAAmB,CAAC;AACrG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAGlE,OAAO,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAI9D,OAAO,EAAE,KAAK,WAAW,EAA4B,MAAM,iBAAiB,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7E;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,gBAAgB,EAC1B,eAAe,EAAE,YAAY,EAC7B,gBAAgB,EAAE,gBAAgB,EAClC,GAAG,yCAA8C,GAChD,OAAO,CAAC,0BAA0B,CAAC,CA+DrC;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,gBAAgB,EAC1B,cAAc,EAAE,WAAW,GAC1B,0BAA0B,CAa5B;AAED,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,MAAM,eAWpB;AAED,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,MAAM,iBAQpB"}

package/dest/private/private_execution.js

@@ -0,0 +1,90 @@
+import { PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { countArgumentsSize } from '@aztec/stdlib/abi';
+import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
+import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
+import { fromACVMField, witnessMapToFields } from './acvm/deserialize.js';
+import { Oracle, extractCallStack } from './acvm/index.js';
+/**
+ * Execute a private function and return the execution result.
+ */ export async function executePrivateFunction(simulator, context, artifact, contractAddress, functionSelector, log = createLogger('simulator:private_execution')) {
+    const functionName = await context.getDebugFunctionName();
+    log.verbose(`Executing private function ${functionName}`, {
+        contract: contractAddress
+    });
+    const acir = artifact.bytecode;
+    const initialWitness = context.getInitialWitness(artifact);
+    const acvmCallback = new Oracle(context);
+    const timer = new Timer();
+    const acirExecutionResult = await simulator.executeUserCircuit(acir, initialWitness, acvmCallback).catch((err)=>{
+        err.message = resolveAssertionMessageFromError(err, artifact);
+        throw new ExecutionError(err.message, {
+            contractAddress,
+            functionSelector
+        }, extractCallStack(err, artifact.debug), {
+            cause: err
+        });
+    });
+    const duration = timer.ms();
+    const partialWitness = acirExecutionResult.partialWitness;
+    const publicInputs = extractPrivateCircuitPublicInputs(artifact, partialWitness);
+    // TODO (alexg) estimate this size
+    const initialWitnessSize = witnessMapToFields(initialWitness).length * Fr.SIZE_IN_BYTES;
+    log.debug(`Ran external function ${contractAddress.toString()}:${functionSelector}`, {
+        circuitName: 'app-circuit',
+        duration,
+        eventName: 'circuit-witness-generation',
+        inputSize: initialWitnessSize,
+        outputSize: publicInputs.toBuffer().length,
+        appCircuitName: functionName
+    });
+    const contractClassLogs = context.getContractClassLogs();
+    const rawReturnValues = await context.loadFromExecutionCache(publicInputs.returnsHash);
+    const noteHashLeafIndexMap = context.getNoteHashLeafIndexMap();
+    const newNotes = context.getNewNotes();
+    const noteHashNullifierCounterMap = context.getNoteHashNullifierCounterMap();
+    const nestedExecutions = context.getNestedExecutions();
+    const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
+    const publicTeardownFunctionCall = context.getPublicTeardownFunctionCall();
+    log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
+    return new PrivateCallExecutionResult(acir, Buffer.from(artifact.verificationKey, 'base64'), partialWitness, publicInputs, noteHashLeafIndexMap, newNotes, noteHashNullifierCounterMap, rawReturnValues, nestedExecutions, enqueuedPublicFunctionCalls, publicTeardownFunctionCall, contractClassLogs);
+}
+/**
+ * Get the private circuit public inputs from the partial witness.
+ * @param artifact - The function artifact
+ * @param partialWitness - The partial witness, result of simulating the function.
+ * @returns - The public inputs.
+ */ export function extractPrivateCircuitPublicInputs(artifact, partialWitness) {
+    const parametersSize = countArgumentsSize(artifact) + PRIVATE_CONTEXT_INPUTS_LENGTH;
+    const returnsSize = PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH;
+    const returnData = [];
+    // Return values always appear in the witness after arguments.
+    for(let i = parametersSize; i < parametersSize + returnsSize; i++){
+        const returnedField = partialWitness.get(i);
+        if (returnedField === undefined) {
+            throw new Error(`Missing return value for index ${i}`);
+        }
+        returnData.push(fromACVMField(returnedField));
+    }
+    return PrivateCircuitPublicInputs.fromFields(returnData);
+}
+export async function readCurrentClassId(contractAddress, instance, node, blockNumber) {
+    const { sharedMutableSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
+    const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, (slot)=>node.getPublicStorageAt(ProtocolContractAddress.ContractInstanceDeployer, slot, blockNumber));
+    let currentClassId = sharedMutableValues.svc.getCurrentAt(blockNumber)[0];
+    if (currentClassId.isZero()) {
+        currentClassId = instance.originalContractClassId;
+    }
+    return currentClassId;
+}
+export async function verifyCurrentClassId(contractAddress, instance, node, blockNumber) {
+    const currentClassId = await readCurrentClassId(contractAddress, instance, node, blockNumber);
+    if (!instance.currentContractClassId.equals(currentClassId)) {
+        throw new Error(`Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`);
+    }
+}

package/dest/{providers → private/providers}/acvm_native.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
-import { type WitnessMap } from '@noir-lang/types';
-import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
-import { type ACVMWitness } from '../acvm/acvm_types.js';
-import { type SimulationProvider } from '../common/simulation_provider.js';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { WitnessMap } from '@noir-lang/types';
+import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
+import type { SimulationProvider } from './simulation_provider.js';
 export declare enum ACVM_RESULT {
     SUCCESS = 0,
     FAILURE = 1

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_native.d.ts","sourceRoot":"","sources":["../../../src/private/providers/acvm_native.ts"],"names":[],"mappings":";;AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAInE,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,GACtB,OAAO,CAAC,UAAU,CAAC,CAqErB;AAED,qBAAa,mBAAoB,YAAW,kBAAkB;IAChD,OAAO,CAAC,gBAAgB;IAAU,OAAO,CAAC,UAAU;IAAU,OAAO,CAAC,eAAe,CAAC;gBAA9E,gBAAgB,EAAE,MAAM,EAAU,UAAU,EAAE,MAAM,EAAU,eAAe,CAAC,oBAAQ;IACpG,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAyB1G,kBAAkB,CAChB,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAC5B,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,mBAAmB,CAAC;CAGhC"}

package/dest/private/providers/acvm_native.js

@@ -0,0 +1,139 @@
+import { runInDirectory } from '@aztec/foundation/fs';
+import { createLogger } 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";
+    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) {
+    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 (error) {
+        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)=>{
+            let outputWitness = Buffer.alloc(0);
+            let errorBuffer = Buffer.alloc(0);
+            const acvm = proc.spawn(pathToAcvm, args);
+            acvm.stdout.on('data', (data)=>{
+                outputWitness = Buffer.concat([
+                    outputWitness,
+                    data
+                ]);
+            });
+            acvm.stderr.on('data', (data)=>{
+                errorBuffer = Buffer.concat([
+                    errorBuffer,
+                    data
+                ]);
+            });
+            acvm.on('close', (code)=>{
+                if (code === 0) {
+                    resolve(outputWitness.toString('utf-8'));
+                } else {
+                    logger.error(`From ACVM: ${errorBuffer.toString('utf-8')}`);
+                    reject(errorBuffer.toString('utf-8'));
+                }
+            });
+        });
+        const duration = new Timer();
+        const output = await processPromise;
+        if (outputFilename) {
+            const outputWitnessFileName = `${workingDirectory}/output-witness.gz`;
+            await fs.copyFile(outputWitnessFileName, outputFilename);
+        }
+        const witness = parseIntoWitnessMap(output);
+        return {
+            status: 0,
+            witness,
+            duration: duration.ms()
+        };
+    } catch (error) {
+        return {
+            status: 1,
+            reason: `${error}`
+        };
+    }
+}
+export class NativeACVMSimulator {
+    workingDirectory;
+    pathToAcvm;
+    witnessFilename;
+    constructor(workingDirectory, pathToAcvm, witnessFilename){
+        this.workingDirectory = workingDirectory;
+        this.pathToAcvm = pathToAcvm;
+        this.witnessFilename = witnessFilename;
+    }
+    async executeProtocolCircuit(input, compiledCircuit) {
+        // Execute the circuit on those initial witness values
+        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');
+            // Execute the circuit
+            const result = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm, this.witnessFilename);
+            if (result.status == 1) {
+                throw new Error(`Failed to generate witness: ${result.reason}`);
+            }
+            return result.witness;
+        };
+        return await runInDirectory(this.workingDirectory, operation, false, logger);
+    }
+    executeUserCircuit(_acir, _initialWitness, _callback) {
+        throw new Error('Not implemented');
+    }
+}

package/dest/{providers → private/providers}/acvm_wasm.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
-import { type WitnessMap } from '@noir-lang/types';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { WitnessMap } from '@noir-lang/types';
 import { type ACIRCallback } from '../acvm/acvm.js';
-import { type ACVMWitness } from '../acvm/acvm_types.js';
-import { type SimulationProvider } from '../common/simulation_provider.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider } from './simulation_provider.js';
 export declare class WASMSimulator implements SimulationProvider {
     protected log: import("@aztec/foundation/log").Logger;
     constructor(log?: import("@aztec/foundation/log").Logger);

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_wasm.d.ts","sourceRoot":"","sources":["../../../src/private/providers/acvm_wasm.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAI9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,kBAAkB,EAAqB,MAAM,0BAA0B,CAAC;AAEtF,qBAAa,aAAc,YAAW,kBAAkB;IAC1C,SAAS,CAAC,GAAG;gBAAH,GAAG,yCAAiC;IAEpD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAUrB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAiCpG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY;CAI3F"}

package/dest/private/providers/acvm_wasm.js

@@ -0,0 +1,62 @@
+import { createLogger } from '@aztec/foundation/log';
+import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
+import initACVM, { executeCircuit } from '@noir-lang/acvm_js';
+import initAbi from '@noir-lang/noirc_abi';
+import { acvm } from '../acvm/acvm.js';
+import { parseErrorPayload } from './simulation_provider.js';
+export class WASMSimulator {
+    log;
+    constructor(log = createLogger('wasm-simulator')){
+        this.log = log;
+    }
+    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, compiledCircuit) {
+        this.log.debug('init', {
+            hash: compiledCircuit.hash
+        });
+        await this.init();
+        // Execute the circuit on those initial witness values
+        //
+        // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+        const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+        //
+        // Execute the circuit
+        try {
+            const _witnessMap = await executeCircuit(decodedBytecode, input, foreignCallHandler);
+            this.log.debug('execution successful', {
+                hash: compiledCircuit.hash
+            });
+            return _witnessMap;
+        } catch (err) {
+            // Typescript types catched 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 = parseErrorPayload(compiledCircuit.abi, err);
+                this.log.debug('execution failed', {
+                    hash: compiledCircuit.hash,
+                    error: parsed,
+                    message: parsed.message
+                });
+                throw parsed;
+            }
+            this.log.debug('execution failed', {
+                hash: compiledCircuit.hash,
+                error: err
+            });
+            throw new Error(`Circuit execution failed: ${err}`);
+        }
+    }
+    async executeUserCircuit(acir, initialWitness, callback) {
+        await this.init();
+        return acvm(acir, initialWitness, callback);
+    }
+}

package/dest/{providers → private/providers}/acvm_wasm_with_blobs.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
-import { type WitnessMap } from '@noir-lang/types';
-import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
-import { type ACVMWitness } from '../acvm/acvm_types.js';
-import { type SimulationProvider } from '../common/simulation_provider.js';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { WitnessMap } from '@noir-lang/types';
+import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider } from './simulation_provider.js';
 /**
  * A simulation provider 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_wasm_with_blobs.d.ts","sourceRoot":"","sources":["../../../src/private/providers/acvm_wasm_with_blobs.ts"],"names":[],"mappings":";;AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,kBAAkB,EAAqB,MAAM,0BAA0B,CAAC;AAEtF;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IACzD,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAwB1G,kBAAkB,CAChB,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAC5B,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,mBAAmB,CAAC;CAGhC"}

package/dest/{providers → private/providers}/acvm_wasm_with_blobs.js

@@ -1,14 +1,13 @@
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
 import { executeCircuit } from '@noir-lang/acvm_js';
-import { parseErrorPayload } from '../common/simulation_provider.js';
+import { parseErrorPayload } from './simulation_provider.js';
 /**
  * A simulation provider 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 {
+ */ export class WASMSimulatorWithBlobs {
     async executeProtocolCircuit(input, compiledCircuit) {
         // Execute the circuit on those initial witness values
         //
@@ -19,8 +18,7 @@ export class WASMSimulatorWithBlobs {
         try {
             const _witnessMap = await executeCircuit(decodedBytecode, input, foreignCallHandler);
             return _witnessMap;
-        }
-        catch (err) {
+        } catch (err) {
             // Typescript types catched 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 parseErrorPayload(compiledCircuit.abi, err);
@@ -32,4 +30,3 @@ export class WASMSimulatorWithBlobs {
         throw new Error('Not implemented');
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN2bV93YXNtX3dpdGhfYmxvYnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXJzL2Fjdm1fd2FzbV93aXRoX2Jsb2JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBR2hGLE9BQU8sRUFBdUIsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFLekUsT0FBTyxFQUEyQixpQkFBaUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRTlGOzs7Ozs7R0FNRztBQUNILE1BQU0sT0FBTyxzQkFBc0I7SUFDakMsS0FBSyxDQUFDLHNCQUFzQixDQUFDLEtBQWlCLEVBQUUsZUFBb0M7UUFDbEYsc0RBQXNEO1FBQ3RELEVBQUU7UUFDRixxRkFBcUY7UUFDckYsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsUUFBUSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ3hFLEVBQUU7UUFDRixzQkFBc0I7UUFDdEIsSUFBSSxDQUFDO1lBQ0gsTUFBTSxXQUFXLEdBQUcsTUFBTSxjQUFjLENBQ3RDLGVBQWUsRUFDZixLQUFLLEVBQ0wsa0JBQWtCLENBQ25CLENBQUM7WUFFRixPQUFPLFdBQVcsQ0FBQztRQUNyQixDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLDZIQUE2SDtZQUM3SCxJQUFJLE9BQU8sR0FBRyxLQUFLLFFBQVEsSUFBSSxHQUFHLEtBQUssSUFBSSxJQUFJLHFCQUFxQixJQUFJLEdBQUcsRUFBRSxDQUFDO2dCQUM1RSxNQUFNLGlCQUFpQixDQUFDLGVBQWUsQ0FBQyxHQUFHLEVBQUUsR0FBcUIsQ0FBQyxDQUFDO1lBQ3RFLENBQUM7WUFDRCxNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixHQUFHLEVBQUUsQ0FBQyxDQUFDO1FBQ3RELENBQUM7SUFDSCxDQUFDO0lBRUQsa0JBQWtCLENBQ2hCLEtBQWEsRUFDYixlQUE0QixFQUM1QixTQUF1QjtRQUV2QixNQUFNLElBQUksS0FBSyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDckMsQ0FBQztDQUNGIn0=

package/dest/{providers → private/providers}/factory.d.ts

@@ -1,5 +1,5 @@
 import { type Logger } from '@aztec/foundation/log';
-import { type SimulationProvider } from '../common/simulation_provider.js';
+import type { SimulationProvider } from './simulation_provider.js';
 export type SimulationProviderConfig = {
     acvmBinaryPath?: string;
     acvmWorkingDirectory?: string;

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

@@ -0,0 +1 @@
+{"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/factory.js

@@ -0,0 +1,27 @@
+import { createLogger } from '@aztec/foundation/log';
+import { promises as fs } from 'fs';
+import { NativeACVMSimulator } from './acvm_native.js';
+import { WASMSimulator } from './acvm_wasm.js';
+export function getSimulationProviderConfigFromEnv() {
+    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 createSimulationProvider(config, logger = createLogger('simulator')) {
+    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}`);
+            return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+        } catch  {
+            logger.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
+        }
+    }
+    logger.info('Using WASM ACVM simulation');
+    return new WASMSimulator();
+}

package/dest/{common → private/providers}/simulation_provider.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
-import { type ExecutionError } from '@noir-lang/acvm_js';
-import { type Abi, type WitnessMap } from '@noir-lang/types';
-import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
-import { type ACVMWitness } from '../acvm/acvm_types.js';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { ExecutionError } from '@noir-lang/acvm_js';
+import type { Abi, WitnessMap } from '@noir-lang/types';
+import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
 /**
  * Low level simulation interface
  */

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulation_provider.d.ts","sourceRoot":"","sources":["../../../src/private/providers/simulation_provider.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACrG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACrH;AAED,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG;IAAE,uBAAuB,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC;AAIlF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,EAAE,aAAa,EAAE,cAAc,GAAG,KAAK,CAuBhF"}