@aztec/simulator 0.23.0 → 0.24.0

package/dest/utils.js

@@ -1,28 +1,12 @@
-import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { pedersenHash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 /**
  * Computes the resulting storage slot for an entry in a mapping.
  * @param mappingSlot - The slot of the mapping within state.
- * @param owner - The key of the mapping.
+ * @param key - The key of the mapping.
  * @returns The slot in the contract storage where the value is stored.
  */
-export function computeSlotForMapping(mappingSlot, owner) {
-    const isFr = (owner) => typeof owner.value === 'bigint';
-    const ownerField = isFr(owner) ? owner : new Fr(owner.x);
-    return Fr.fromBuffer(pedersenHash([mappingSlot, ownerField].map(f => f.toBuffer())));
+export function computeSlotForMapping(mappingSlot, key) {
+    return Fr.fromBuffer(pedersenHash([mappingSlot, key.toField()].map(field => field.toBuffer())));
 }
-/**
- * Computes the public key for a private key.
- * @param privateKey - The private key.
- * @param grumpkin - The grumpkin instance.
- * @returns The public key.
- */
-export function toPublicKey(privateKey, grumpkin) {
-    const point = grumpkin.mul(Grumpkin.generator, privateKey);
-    return {
-        x: point.x.value,
-        y: point.y.value,
-    };
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzNELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFZOUM7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQUMsV0FBZSxFQUFFLEtBQXFCO0lBQzFFLE1BQU0sSUFBSSxHQUFHLENBQUMsS0FBcUIsRUFBZSxFQUFFLENBQUMsT0FBUSxLQUFZLENBQUMsS0FBSyxLQUFLLFFBQVEsQ0FBQztJQUM3RixNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXpELE9BQU8sRUFBRSxDQUFDLFVBQVUsQ0FBQyxZQUFZLENBQUMsQ0FBQyxXQUFXLEVBQUUsVUFBVSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ3ZGLENBQUM7QUFFRDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxXQUFXLENBQUMsVUFBOEIsRUFBRSxRQUFrQjtJQUM1RSxNQUFNLEtBQUssR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxTQUFTLEVBQUUsVUFBVSxDQUFDLENBQUM7SUFDM0QsT0FBTztRQUNMLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLEtBQUs7UUFDaEIsQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSztLQUNqQixDQUFDO0FBQ0osQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUU5Qzs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxxQkFBcUIsQ0FDbkMsV0FBZSxFQUNmLEdBR0M7SUFFRCxPQUFPLEVBQUUsQ0FBQyxVQUFVLENBQUMsWUFBWSxDQUFDLENBQUMsV0FBVyxFQUFFLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNsRyxDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -30,9 +30,9 @@
     "rootDir": "./src"
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.23.0",
-    "@aztec/circuits.js": "0.23.0",
-    "@aztec/foundation": "0.23.0",
+    "@aztec/circuit-types": "0.24.0",
+    "@aztec/circuits.js": "0.24.0",
+    "@aztec/foundation": "0.24.0",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
     "levelup": "^5.1.1",
     "memdown": "^6.1.1",
@@ -41,14 +41,16 @@
   "devDependencies": {
     "@aztec/kv-store": "workspace:^",
     "@aztec/merkle-tree": "workspace:^",
-    "@aztec/noir-contracts": "workspace:^",
+    "@aztec/noir-contracts.js": "workspace:^",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/levelup": "^5.1.3",
+    "@types/lodash.merge": "^4.6.9",
     "@types/memdown": "^3.0.2",
     "@types/node": "^18.7.23",
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.4",
+    "lodash.merge": "^4.6.2",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4",

package/src/acvm/acvm.ts

@@ -0,0 +1,156 @@
+import { NoirCallStack, SourceCodeLocation } from '@aztec/circuit-types';
+import { FunctionDebugMetadata, OpcodeLocation } from '@aztec/foundation/abi';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import {
+  ExecutionError,
+  ForeignCallInput,
+  ForeignCallOutput,
+  WasmBlackBoxFunctionSolver,
+  executeCircuitWithBlackBoxSolver,
+} from '@noir-lang/acvm_js';
+
+import { traverseCauseChain } from '../common/errors.js';
+import { ACVMWitness } from './acvm_types.js';
+import { ORACLE_NAMES } from './oracle/index.js';
+
+/**
+ * The callback interface for the ACIR.
+ */
+type ACIRCallback = Record<
+  ORACLE_NAMES,
+  (...args: ForeignCallInput[]) => ForeignCallOutput | Promise<ForeignCallOutput>
+>;
+
+/**
+ * The result of executing an ACIR.
+ */
+export interface ACIRExecutionResult {
+  /**
+   * The partial witness of the execution.
+   */
+  partialWitness: ACVMWitness;
+}
+
+/**
+ * Extracts the call stack from the location of a failing opcode and the debug metadata.
+ * One opcode can point to multiple calls due to inlining.
+ */
+function getSourceCodeLocationsFromOpcodeLocation(
+  opcodeLocation: string,
+  debug: FunctionDebugMetadata,
+): SourceCodeLocation[] {
+  const { debugSymbols, files } = debug;
+
+  const callStack = debugSymbols.locations[opcodeLocation] || [];
+  return callStack.map(call => {
+    const { file: fileId, span } = call;
+
+    const { path, source } = files[fileId];
+
+    const locationText = source.substring(span.start, span.end);
+    const precedingText = source.substring(0, span.start);
+    const previousLines = precedingText.split('\n');
+    // Lines and columns in stacks are one indexed.
+    const line = previousLines.length;
+    const column = previousLines[previousLines.length - 1].length + 1;
+
+    return {
+      filePath: path,
+      line,
+      column,
+      fileSource: source,
+      locationText,
+    };
+  });
+}
+
+/**
+ * Extracts the source code locations for an array of opcode locations
+ * @param opcodeLocations - The opcode locations that caused the error.
+ * @param debug - The debug metadata of the function.
+ * @returns The source code locations.
+ */
+export function resolveOpcodeLocations(
+  opcodeLocations: OpcodeLocation[],
+  debug: FunctionDebugMetadata,
+): SourceCodeLocation[] {
+  return opcodeLocations.flatMap(opcodeLocation => getSourceCodeLocationsFromOpcodeLocation(opcodeLocation, debug));
+}
+
+/**
+ * The function call that executes an ACIR.
+ */
+export async function acvm(
+  solver: WasmBlackBoxFunctionSolver,
+  acir: Buffer,
+  initialWitness: ACVMWitness,
+  callback: ACIRCallback,
+): Promise<ACIRExecutionResult> {
+  const logger = createDebugLogger('aztec:simulator:acvm');
+
+  const partialWitness = await executeCircuitWithBlackBoxSolver(
+    solver,
+    acir,
+    initialWitness,
+    async (name: string, args: ForeignCallInput[]) => {
+      try {
+        logger(`Oracle callback ${name}`);
+        const oracleFunction = callback[name as ORACLE_NAMES];
+        if (!oracleFunction) {
+          throw new Error(`Oracle callback ${name} not found`);
+        }
+
+        const result = await oracleFunction.call(callback, ...args);
+        return [result];
+      } catch (err) {
+        let typedError: Error;
+        if (err instanceof Error) {
+          typedError = err;
+        } else {
+          typedError = new Error(`Error in oracle callback ${err}`);
+        }
+        logger.error(`Error in oracle callback ${name}`);
+        throw typedError;
+      }
+    },
+  ).catch((err: Error) => {
+    // Wasm callbacks act as a boundary for stack traces, so we capture it here and complete the error if it happens.
+    const stack = new Error().stack;
+
+    traverseCauseChain(err, cause => {
+      if (cause.stack) {
+        cause.stack += stack;
+      }
+    });
+
+    throw err;
+  });
+
+  return { partialWitness };
+}
+
+/**
+ * Extracts the call stack from an thrown by the acvm.
+ * @param error - The error to extract from.
+ * @param debug - The debug metadata of the function called.
+ * @returns The call stack, if available.
+ */
+export function extractCallStack(
+  error: Error | ExecutionError,
+  debug?: FunctionDebugMetadata,
+): NoirCallStack | undefined {
+  if (!('callStack' in error) || !error.callStack) {
+    return undefined;
+  }
+  const { callStack } = error;
+  if (!debug) {
+    return callStack;
+  }
+
+  try {
+    return resolveOpcodeLocations(callStack, debug);
+  } catch (err) {
+    return callStack;
+  }
+}

package/src/acvm/acvm_types.ts

@@ -0,0 +1,11 @@
+import { WitnessMap } from '@noir-lang/acvm_js';
+
+/**
+ * ACVMField
+ */
+export type ACVMField = string;
+
+/**
+ * The format for witnesses of the ACVM.
+ */
+export type ACVMWitness = WitnessMap;

package/src/acvm/deserialize.ts

@@ -0,0 +1,36 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import { getReturnWitness } from '@noir-lang/acvm_js';
+
+import { ACVMField, ACVMWitness } from './acvm_types.js';
+
+/**
+ * Converts an ACVM field to a Fr.
+ * @param field - The ACVM field to convert.
+ * @returns The Fr.
+ */
+export function fromACVMField(field: ACVMField): Fr {
+  return Fr.fromBuffer(Buffer.from(field.slice(2), 'hex'));
+}
+
+/**
+ * Converts a field to a number.
+ * @param fr - The field to convert.
+ * @returns The number.
+ * TODO(#4102): Nuke this once block number is big int.
+ */
+export function frToNumber(fr: Fr): number {
+  return Number(fr.value);
+}
+
+/**
+ * Extracts the return fields of a given partial witness.
+ * @param acir - The bytecode of the function.
+ * @param partialWitness - The witness to extract from.
+ * @returns The return values.
+ */
+export function extractReturnWitness(acir: Buffer, partialWitness: ACVMWitness): Fr[] {
+  const returnWitness = getReturnWitness(acir, partialWitness);
+  const sortedKeys = [...returnWitness.keys()].sort((a, b) => a - b);
+  return sortedKeys.map(key => returnWitness.get(key)!).map(fromACVMField);
+}

package/src/acvm/index.ts

@@ -0,0 +1,5 @@
+export * from './acvm.js';
+export * from './acvm_types.js';
+export * from './deserialize.js';
+export * from './oracle/index.js';
+export * from './serialize.js';

package/src/acvm/oracle/debug.ts

@@ -0,0 +1,109 @@
+import { ForeignCallInput } from '@noir-lang/acvm_js';
+
+import { ACVMField } from '../acvm_types.js';
+
+/**
+ * Convert an array of ACVMFields to a string.
+ *
+ * @param msg - array of ACVMFields where each represents a single ascii character
+ * @returns string representation of the message
+ */
+export function acvmFieldMessageToString(msg: ACVMField[]): string {
+  let msgStr = '';
+  for (const msgChar of msg) {
+    const asciiCode = Number(msgChar);
+    const asciiChar = String.fromCharCode(asciiCode);
+    msgStr = msgStr.concat(asciiChar);
+  }
+  // cut off string in case of preemptive null termination
+  const nullCharIndex = msgStr.indexOf('\\0');
+  if (nullCharIndex >= 0) {
+    msgStr = msgStr.substring(0, nullCharIndex);
+  }
+  return msgStr.replaceAll('\\n', '\n').replaceAll('\\t', '\t');
+}
+
+/**
+ * Format a debug string for Aztec.nr filling in `'{0}'` entries with their
+ * corresponding values from the args array.
+ *
+ * @param formatStr - str of form `'this is a string with some entries like {0} and {1}'`
+ * @param args - array of fields to fill in the string format entries with
+ * @returns formatted string
+ */
+function applyStringFormatting(formatStr: string, args: ACVMField[]): string {
+  const matches = formatStr.match(/{\d+}/g);
+  if (matches == null) {
+    return formatStr;
+  }
+  // Get the numeric values within the curly braces, convert them to numbers,
+  // and find the maximum value.
+  const maxIndex = Math.max(...matches.map(match => Number(match.slice(1, -1))));
+  const argsPadded = args.concat(Array.from({ length: Math.max(0, maxIndex - args.length) }, () => '0xBAD'));
+
+  return formatStr.replace(/{(\d+)}/g, function (match, index) {
+    return typeof args[index] != 'undefined' ? argsPadded[index] : match;
+  });
+}
+
+/**
+ * Convert an array of ACVMFields from ACVM to a formatted string.
+ *
+ * @param parameters - either one parameter representing a simple field or array, or two parameters when
+ * It's a message without args or three parameters when it's a message with arguments.
+ *
+ * @returns formatted string
+ */
+export function oracleDebugCallToFormattedStr(parameters: ForeignCallInput[]): string {
+  if (parameters.length === 1) {
+    return processFieldOrArray(parameters[0]);
+  }
+
+  let formatArgs: string[] = [];
+
+  if (parameters.length > 2) {
+    formatArgs = parameters[1];
+  }
+
+  const formattedMsg = applyStringFormatting(acvmFieldMessageToString(parameters[0]), formatArgs);
+
+  return formattedMsg;
+}
+
+/**
+ * Processes a field or an array and returns a string representation.
+ * @param fieldOrArray - The field or array to be processed.
+ * @returns Returns the processed string representation of the field or array.
+ */
+function processFieldOrArray(fieldOrArray: string[]) {
+  if (fieldOrArray.length === 1) {
+    return `${fieldOrArray[0]}`;
+  }
+
+  // Check if all the elements start with 63 zero bytes
+  // --> if yes, we have an array of bytes and we print as hex
+  if (onlyBytes(fieldOrArray)) {
+    const decimalArray = fieldOrArray.map(element => parseInt(element, 16));
+    return '0x' + Buffer.from(decimalArray).toString('hex');
+  }
+
+  return '[' + fieldOrArray.join(', ') + ']';
+}
+
+/**
+ * Checks if all elements in the array are valid byte representations.
+ * @param array - The array to be checked.
+ * @returns Returns `true` if all elements are valid byte representations, `false` otherwise.
+ * @throws Throws an error if any element has an invalid length.
+ */
+function onlyBytes(array: string[]): boolean {
+  for (const element of array) {
+    if (element.length != 66) {
+      throw new Error('Invalid element length. Expected 66 chars, got ' + element.length + ' chars.');
+    }
+    if (!element.startsWith('0x00000000000000000000000000000000000000000000000000000000000000')) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/acvm/oracle/index.ts

@@ -0,0 +1,17 @@
+import { Oracle } from './oracle.js';
+
+export * from './debug.js';
+export * from './oracle.js';
+export * from './typed_oracle.js';
+
+/**
+ * A conditional type that takes a type `T` and returns a union of its method names.
+ */
+type MethodNames<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+/**
+ * Available oracle function names.
+ */
+export type ORACLE_NAMES = MethodNames<Oracle>;