@aztec/simulator 0.23.0 → 0.26.1

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,44 @@
+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);
+}
+
+/**
+ * Converts a field to a boolean.
+ * @param fr - The field to convert.
+ */
+export function frToBoolean(fr: Fr): boolean {
+  return fr.toBigInt() === BigInt(1);
+}
+
+/**
+ * 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>;

package/src/acvm/oracle/oracle.ts

@@ -0,0 +1,356 @@
+import { MerkleTreeId, UnencryptedL2Log } from '@aztec/circuit-types';
+import { RETURN_VALUES_LENGTH } from '@aztec/circuits.js';
+import { EventSelector, FunctionSelector } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr, Point } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import { ACVMField } from '../acvm_types.js';
+import { frToBoolean, frToNumber, fromACVMField } from '../deserialize.js';
+import { toACVMField, toAcvmEnqueuePublicFunctionResult } from '../serialize.js';
+import { acvmFieldMessageToString, oracleDebugCallToFormattedStr } from './debug.js';
+import { TypedOracle } from './typed_oracle.js';
+
+/**
+ * A data source that has all the apis required by Aztec.nr.
+ */
+export class Oracle {
+  constructor(private typedOracle: TypedOracle, private log = createDebugLogger('aztec:simulator:oracle')) {}
+
+  getRandomField(): ACVMField {
+    const val = this.typedOracle.getRandomField();
+    return toACVMField(val);
+  }
+
+  async packArguments(args: ACVMField[]): Promise<ACVMField> {
+    const packed = await this.typedOracle.packArguments(args.map(fromACVMField));
+    return toACVMField(packed);
+  }
+
+  async getNullifierKeyPair([accountAddress]: ACVMField[]): Promise<ACVMField[]> {
+    const { publicKey, secretKey } = await this.typedOracle.getNullifierKeyPair(fromACVMField(accountAddress));
+    return [
+      toACVMField(publicKey.x),
+      toACVMField(publicKey.y),
+      toACVMField(secretKey.high),
+      toACVMField(secretKey.low),
+    ];
+  }
+
+  async getPublicKeyAndPartialAddress([address]: ACVMField[]) {
+    const { publicKey, partialAddress } = await this.typedOracle.getCompleteAddress(
+      AztecAddress.fromField(fromACVMField(address)),
+    );
+    return [publicKey.x, publicKey.y, partialAddress].map(toACVMField);
+  }
+
+  async getContractInstance([address]: ACVMField[]) {
+    const instance = await this.typedOracle.getContractInstance(AztecAddress.fromField(fromACVMField(address)));
+    // TODO(#4434) Add deployer field to ContractInstance
+    const deployer = Fr.ZERO;
+    return [
+      instance.salt,
+      deployer,
+      instance.contractClassId,
+      instance.initializationHash,
+      instance.portalContractAddress,
+      instance.publicKeysHash,
+    ].map(toACVMField);
+  }
+
+  async getMembershipWitness(
+    [blockNumber]: ACVMField[],
+    [treeId]: ACVMField[],
+    [leafValue]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
+    const parsedTreeId = frToNumber(fromACVMField(treeId));
+    const parsedLeafValue = fromACVMField(leafValue);
+
+    const witness = await this.typedOracle.getMembershipWitness(parsedBlockNumber, parsedTreeId, parsedLeafValue);
+    if (!witness) {
+      throw new Error(
+        `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block ${parsedBlockNumber}.`,
+      );
+    }
+    return witness.map(toACVMField);
+  }
+
+  async getSiblingPath(
+    [blockNumber]: ACVMField[],
+    [treeId]: ACVMField[],
+    [leafIndex]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
+    const parsedTreeId = frToNumber(fromACVMField(treeId));
+    const parsedLeafIndex = fromACVMField(leafIndex);
+
+    const path = await this.typedOracle.getSiblingPath(parsedBlockNumber, parsedTreeId, parsedLeafIndex);
+    return path.map(toACVMField);
+  }
+
+  async getNullifierMembershipWitness(
+    [blockNumber]: ACVMField[],
+    [nullifier]: ACVMField[], // nullifier, we try to find the witness for (to prove inclusion)
+  ): Promise<ACVMField[]> {
+    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
+    const parsedNullifier = fromACVMField(nullifier);
+
+    const witness = await this.typedOracle.getNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
+    if (!witness) {
+      throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
+    }
+    return witness.toFields().map(toACVMField);
+  }
+
+  async getLowNullifierMembershipWitness(
+    [blockNumber]: ACVMField[],
+    [nullifier]: ACVMField[], // nullifier, we try to find the low nullifier witness for (to prove non-inclusion)
+  ): Promise<ACVMField[]> {
+    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
+    const parsedNullifier = fromACVMField(nullifier);
+
+    const witness = await this.typedOracle.getLowNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
+    if (!witness) {
+      throw new Error(
+        `Low nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`,
+      );
+    }
+    return witness.toFields().map(toACVMField);
+  }
+
+  async getPublicDataTreeWitness([blockNumber]: ACVMField[], [leafSlot]: ACVMField[]): Promise<ACVMField[]> {
+    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
+    const parsedLeafSlot = fromACVMField(leafSlot);
+
+    const witness = await this.typedOracle.getPublicDataTreeWitness(parsedBlockNumber, parsedLeafSlot);
+    if (!witness) {
+      throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
+    }
+    return witness.toFields().map(toACVMField);
+  }
+
+  async getHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]> {
+    const parsedBlockNumber = frToNumber(fromACVMField(blockNumber));
+
+    const header = await this.typedOracle.getHeader(parsedBlockNumber);
+    if (!header) {
+      throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
+    }
+    return header.toFields().map(toACVMField);
+  }
+
+  async getAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[]> {
+    const messageHashField = fromACVMField(messageHash);
+    const witness = await this.typedOracle.getAuthWitness(messageHashField);
+    if (!witness) {
+      throw new Error(`Authorization not found for message hash ${messageHashField}`);
+    }
+    return witness.map(toACVMField);
+  }
+
+  async popCapsule(): Promise<ACVMField[]> {
+    const capsule = await this.typedOracle.popCapsule();
+    if (!capsule) {
+      throw new Error(`No capsules available`);
+    }
+    return capsule.map(toACVMField);
+  }
+
+  async getNotes(
+    [storageSlot]: ACVMField[],
+    [numSelects]: ACVMField[],
+    selectBy: ACVMField[],
+    selectValues: ACVMField[],
+    selectComparators: ACVMField[],
+    sortBy: ACVMField[],
+    sortOrder: ACVMField[],
+    [limit]: ACVMField[],
+    [offset]: ACVMField[],
+    [status]: ACVMField[],
+    [returnSize]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const noteDatas = await this.typedOracle.getNotes(
+      fromACVMField(storageSlot),
+      +numSelects,
+      selectBy.map(s => +s),
+      selectValues.map(fromACVMField),
+      selectComparators.map(s => +s),
+      sortBy.map(s => +s),
+      sortOrder.map(s => +s),
+      +limit,
+      +offset,
+      +status,
+    );
+
+    const noteLength = noteDatas?.[0]?.note.items.length ?? 0;
+    if (!noteDatas.every(({ note }) => noteLength === note.items.length)) {
+      throw new Error('Notes should all be the same length.');
+    }
+
+    const contractAddress = noteDatas[0]?.contractAddress ?? Fr.ZERO;
+
+    // Values indicates whether the note is settled or transient.
+    const noteTypes = {
+      isSettled: new Fr(0),
+      isTransient: new Fr(1),
+    };
+    const flattenData = noteDatas.flatMap(({ nonce, note, index }) => [
+      nonce,
+      index === undefined ? noteTypes.isTransient : noteTypes.isSettled,
+      ...note.items,
+    ]);
+
+    const returnFieldSize = +returnSize;
+    const returnData = [noteDatas.length, contractAddress, ...flattenData].map(v => toACVMField(v));
+    if (returnData.length > returnFieldSize) {
+      throw new Error(`Return data size too big. Maximum ${returnFieldSize} fields. Got ${flattenData.length}.`);
+    }
+
+    const paddedZeros = Array(returnFieldSize - returnData.length).fill(toACVMField(0));
+    return returnData.concat(paddedZeros);
+  }
+
+  notifyCreatedNote(
+    [storageSlot]: ACVMField[],
+    [noteTypeId]: ACVMField[],
+    note: ACVMField[],
+    [innerNoteHash]: ACVMField[],
+  ): ACVMField {
+    this.typedOracle.notifyCreatedNote(
+      fromACVMField(storageSlot),
+      fromACVMField(noteTypeId),
+      note.map(fromACVMField),
+      fromACVMField(innerNoteHash),
+    );
+    return toACVMField(0);
+  }
+
+  async notifyNullifiedNote([innerNullifier]: ACVMField[], [innerNoteHash]: ACVMField[]): Promise<ACVMField> {
+    await this.typedOracle.notifyNullifiedNote(fromACVMField(innerNullifier), fromACVMField(innerNoteHash));
+    return toACVMField(0);
+  }
+
+  async checkNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField> {
+    const exists = await this.typedOracle.checkNullifierExists(fromACVMField(innerNullifier));
+    return toACVMField(exists);
+  }
+
+  async getL1ToL2MembershipWitness([entryKey]: ACVMField[]): Promise<ACVMField[]> {
+    const message = await this.typedOracle.getL1ToL2MembershipWitness(fromACVMField(entryKey));
+    return message.toFields().map(toACVMField);
+  }
+
+  async getPortalContractAddress([aztecAddress]: ACVMField[]): Promise<ACVMField> {
+    const contractAddress = AztecAddress.fromString(aztecAddress);
+    const portalContactAddress = await this.typedOracle.getPortalContractAddress(contractAddress);
+    return toACVMField(portalContactAddress);
+  }
+
+  async storageRead([startStorageSlot]: ACVMField[], [numberOfElements]: ACVMField[]): Promise<ACVMField[]> {
+    const values = await this.typedOracle.storageRead(fromACVMField(startStorageSlot), +numberOfElements);
+    return values.map(toACVMField);
+  }
+
+  async storageWrite([startStorageSlot]: ACVMField[], values: ACVMField[]): Promise<ACVMField[]> {
+    const newValues = await this.typedOracle.storageWrite(fromACVMField(startStorageSlot), values.map(fromACVMField));
+    return newValues.map(toACVMField);
+  }
+
+  emitEncryptedLog(
+    [contractAddress]: ACVMField[],
+    [storageSlot]: ACVMField[],
+    [noteTypeId]: ACVMField[],
+    [publicKeyX]: ACVMField[],
+    [publicKeyY]: ACVMField[],
+    log: ACVMField[],
+  ): ACVMField {
+    const publicKey = new Point(fromACVMField(publicKeyX), fromACVMField(publicKeyY));
+    this.typedOracle.emitEncryptedLog(
+      AztecAddress.fromString(contractAddress),
+      Fr.fromString(storageSlot),
+      Fr.fromString(noteTypeId),
+      publicKey,
+      log.map(fromACVMField),
+    );
+    return toACVMField(0);
+  }
+
+  emitUnencryptedLog([contractAddress]: ACVMField[], [eventSelector]: ACVMField[], message: ACVMField[]): ACVMField {
+    const logPayload = Buffer.concat(message.map(fromACVMField).map(f => f.toBuffer()));
+    const log = new UnencryptedL2Log(
+      AztecAddress.fromString(contractAddress),
+      EventSelector.fromField(fromACVMField(eventSelector)),
+      logPayload,
+    );
+
+    this.typedOracle.emitUnencryptedLog(log);
+    return toACVMField(0);
+  }
+
+  debugLog(...args: ACVMField[][]): ACVMField {
+    this.log(oracleDebugCallToFormattedStr(args));
+    return toACVMField(0);
+  }
+
+  debugLogWithPrefix(arg0: ACVMField[], ...args: ACVMField[][]): ACVMField {
+    this.log(`${acvmFieldMessageToString(arg0)}: ${oracleDebugCallToFormattedStr(args)}`);
+    return toACVMField(0);
+  }
+
+  async callPrivateFunction(
+    [contractAddress]: ACVMField[],
+    [functionSelector]: ACVMField[],
+    [argsHash]: ACVMField[],
+    [sideffectCounter]: ACVMField[],
+    [isStaticCall]: ACVMField[],
+    [isDelegateCall]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const callStackItem = await this.typedOracle.callPrivateFunction(
+      AztecAddress.fromField(fromACVMField(contractAddress)),
+      FunctionSelector.fromField(fromACVMField(functionSelector)),
+      fromACVMField(argsHash),
+      frToNumber(fromACVMField(sideffectCounter)),
+      frToBoolean(fromACVMField(isStaticCall)),
+      frToBoolean(fromACVMField(isDelegateCall)),
+    );
+    return callStackItem.toFields().map(toACVMField);
+  }
+
+  async callPublicFunction(
+    [contractAddress]: ACVMField[],
+    [functionSelector]: ACVMField[],
+    [argsHash]: ACVMField[],
+    [isStaticCall]: ACVMField[],
+    [isDelegateCall]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const returnValues = await this.typedOracle.callPublicFunction(
+      AztecAddress.fromField(fromACVMField(contractAddress)),
+      FunctionSelector.fromField(fromACVMField(functionSelector)),
+      fromACVMField(argsHash),
+      frToBoolean(fromACVMField(isStaticCall)),
+      frToBoolean(fromACVMField(isDelegateCall)),
+    );
+    return padArrayEnd(returnValues, Fr.ZERO, RETURN_VALUES_LENGTH).map(toACVMField);
+  }
+
+  async enqueuePublicFunctionCall(
+    [contractAddress]: ACVMField[],
+    [functionSelector]: ACVMField[],
+    [argsHash]: ACVMField[],
+    [sideffectCounter]: ACVMField[],
+    [isStaticCall]: ACVMField[],
+    [isDelegateCall]: ACVMField[],
+  ) {
+    const enqueuedRequest = await this.typedOracle.enqueuePublicFunctionCall(
+      AztecAddress.fromString(contractAddress),
+      FunctionSelector.fromField(fromACVMField(functionSelector)),
+      fromACVMField(argsHash),
+      frToNumber(fromACVMField(sideffectCounter)),
+      frToBoolean(fromACVMField(isStaticCall)),
+      frToBoolean(fromACVMField(isDelegateCall)),
+    );
+    return toAcvmEnqueuePublicFunctionResult(enqueuedRequest);
+  }
+}