@aztec/simulator 0.87.4 → 0.87.6

package/src/private/execution_note_cache.ts

@@ -1,217 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
-
-import type { NoteData } from './acvm/index.js';
-
-interface PendingNote {
-  note: NoteData;
-  counter: number;
-  noteHashForConsumption: Fr;
-}
-
-/**
- * Data that's accessible by all the function calls in an execution.
- */
-export class ExecutionNoteCache {
-  /**
-   * New notes created in this transaction.
-   * They are pushed to this array in the same order as they are emitted.
-   */
-  private notes: PendingNote[] = [];
-  /**
-   * This mapping maps from a contract address to the notes in the contract.
-   */
-  private noteMap: Map<bigint, PendingNote[]> = new Map();
-
-  /**
-   * This maps from a contract address to the nullifiers emitted from the contract.
-   * The note which is nullified might be new or not (i.e., was generated in a previous transaction).
-   * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
-   */
-  private nullifierMap: Map<bigint, Set<bigint>> = new Map();
-
-  /**
-   * All nullifiers emitted in this transaction.
-   */
-  private allNullifiers: Set<bigint> = new Set();
-
-  private minRevertibleSideEffectCounter = 0;
-
-  private inRevertiblePhase = false;
-
-  /**
-   * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
-   * In that case we disable injecting the tx request hash as a nullifier.
-   */
-  private usedTxRequestHashForNonces = true;
-
-  constructor(private readonly txRequestHash: Fr) {}
-
-  /**
-   * Enters the revertible phase of the transaction.
-   * @param minRevertibleSideEffectCounter - The counter at which the transaction enters the revertible phase.
-   */
-  public async setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
-    if (this.inRevertiblePhase) {
-      throw new Error(
-        `Cannot enter the revertible phase twice. Current counter: ${minRevertibleSideEffectCounter}. Previous enter counter: ${this.minRevertibleSideEffectCounter}`,
-      );
-    }
-    this.inRevertiblePhase = true;
-    this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
-
-    let nonceGenerator = this.txRequestHash;
-    const nullifiers = this.getAllNullifiers();
-    if (nullifiers.length > 0) {
-      nonceGenerator = new Fr(nullifiers[0]);
-      this.usedTxRequestHashForNonces = false;
-    }
-
-    // The existing pending notes are all non-revertible.
-    // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
-    // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
-    // The nonces will be used to create the "complete" nullifier.
-    const updatedNotes = await Promise.all(
-      this.notes.map(async ({ note, counter }, i) => {
-        const nonce = await computeNoteHashNonce(nonceGenerator, i);
-        const uniqueNoteHash = await computeUniqueNoteHash(
-          nonce,
-          await siloNoteHash(note.contractAddress, note.noteHash),
-        );
-        return {
-          counter,
-          note: { ...note, nonce },
-          noteHashForConsumption: uniqueNoteHash,
-        };
-      }),
-    );
-    // Rebuild the data.
-    this.notes = [];
-    this.noteMap = new Map();
-    updatedNotes.forEach(n => this.#addNote(n));
-  }
-
-  public finish() {
-    // If we never entered the revertible phase, we need to use the tx request hash as a nonce for the notes if no nullifiers have been emitted.
-    if (!this.inRevertiblePhase) {
-      this.usedTxRequestHashForNonces = this.getAllNullifiers().length === 0;
-    }
-    // If we entered the revertible phase, the nonce generator was decided based on wether or not a nullifier was emitted before entering.
-    return {
-      usedTxRequestHashForNonces: this.usedTxRequestHashForNonces,
-    };
-  }
-
-  /**
-   * Add a new note to cache.
-   * @param note - New note created during execution.
-   */
-  public addNewNote(note: NoteData, counter: number) {
-    const previousNote = this.notes[this.notes.length - 1];
-    if (previousNote && previousNote.counter >= counter) {
-      throw new Error(
-        `Note hash counters must be strictly increasing. Current counter: ${counter}. Previous counter: ${previousNote.counter}.`,
-      );
-    }
-
-    this.#addNote({ note, counter, noteHashForConsumption: note.noteHash });
-  }
-
-  /**
-   * Add a nullifier to cache. It could be for a db note or a new note created during execution.
-   * @param contractAddress - Contract address of the note.
-   * @param innerNullifier - Inner nullifier of the note.
-   * @param noteHash - A hash of the note. If this value equals 0, it means the note being nullified is from a previous
-   * transaction (and thus not a new note).
-   */
-  public async nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr) {
-    const siloedNullifier = await siloNullifier(contractAddress, innerNullifier);
-    let nullifiedNoteHashCounter: number | undefined = undefined;
-    // Find and remove the matching new note and log(s) if the emitted noteHash is not empty.
-    if (!noteHash.isEmpty()) {
-      const notesInContract = this.noteMap.get(contractAddress.toBigInt()) ?? [];
-      const noteIndexToRemove = notesInContract.findIndex(n => n.noteHashForConsumption.equals(noteHash));
-      if (noteIndexToRemove === -1) {
-        throw new Error('Attempt to remove a pending note that does not exist.');
-      }
-
-      const note = notesInContract.splice(noteIndexToRemove, 1)[0];
-      nullifiedNoteHashCounter = note.counter;
-      this.noteMap.set(contractAddress.toBigInt(), notesInContract);
-      this.notes = this.notes.filter(n => n.counter !== note.counter);
-
-      // If the note is non revertible and the nullifier was emitted in the revertible phase, both the note hash and the nullifier will be emitted
-      if (this.inRevertiblePhase && note.counter < this.minRevertibleSideEffectCounter) {
-        this.recordNullifier(contractAddress, siloedNullifier);
-      }
-    } else {
-      // If the note being nullified comes from a previous tx the nullifier will be emitted.
-      this.recordNullifier(contractAddress, siloedNullifier);
-    }
-    return nullifiedNoteHashCounter;
-  }
-
-  /**
-   * Adds a nullifier to the cache. Note cache needs to track all nullifiers to decide which nullifier to use for note siloing.
-   * @param contractAddress - Contract address that emitted the nullifier.
-   * @param innerNullifier
-   */
-  public async nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
-    const siloedNullifier = await siloNullifier(contractAddress, innerNullifier);
-    this.recordNullifier(contractAddress, siloedNullifier);
-  }
-
-  /**
-   * Return notes created up to current point in execution.
-   * If a nullifier for a note in this list is emitted, the note will be deleted.
-   * @param contractAddress - Contract address of the notes.
-   * @param storageSlot - Storage slot of the notes.
-   **/
-  public getNotes(contractAddress: AztecAddress, storageSlot: Fr) {
-    const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
-    return notes.filter(n => n.note.storageSlot.equals(storageSlot)).map(n => n.note);
-  }
-
-  /**
-   * Check if a note exists in the newNotes array.
-   * @param contractAddress - Contract address of the note.
-   * @param storageSlot - Storage slot of the note.
-   * @param noteHash - A hash of the note.
-   **/
-  public checkNoteExists(contractAddress: AztecAddress, noteHash: Fr) {
-    const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
-    return notes.some(n => n.note.noteHash.equals(noteHash));
-  }
-
-  /**
-   * Return all nullifiers emitted from a contract.
-   * @param contractAddress - Address of the contract.
-   */
-  public getNullifiers(contractAddress: AztecAddress): Set<bigint> {
-    return this.nullifierMap.get(contractAddress.toBigInt()) ?? new Set();
-  }
-
-  #addNote(note: PendingNote) {
-    this.notes.push(note);
-
-    const notes = this.noteMap.get(note.note.contractAddress.toBigInt()) ?? [];
-    notes.push(note);
-    this.noteMap.set(note.note.contractAddress.toBigInt(), notes);
-  }
-
-  getAllNotes(): PendingNote[] {
-    return this.notes;
-  }
-
-  getAllNullifiers(): Fr[] {
-    return [...this.allNullifiers].map(n => new Fr(n));
-  }
-
-  recordNullifier(contractAddress: AztecAddress, siloedNullifier: Fr) {
-    const nullifiers = this.getNullifiers(contractAddress);
-    nullifiers.add(siloedNullifier.toBigInt());
-    this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
-    this.allNullifiers.add(siloedNullifier.toBigInt());
-  }
-}

package/src/private/hashed_values_cache.ts

@@ -1,47 +0,0 @@
-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 {
-  private cache: Map<bigint, Fr[]>;
-
-  constructor(initialArguments: HashedValues[] = []) {
-    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.
-   */
-  public static create(initialArguments: HashedValues[] = []) {
-    return new HashedValuesCache(initialArguments);
-  }
-
-  /**
-   * Gets preimage of a hash.
-   * @param hash - The hash to get the preimage of.
-   * @returns The preimage.
-   */
-  public getPreimage(hash: Fr): Fr[] | undefined {
-    if (hash.isEmpty()) {
-      return [];
-    } else {
-      return this.cache.get(hash.toBigInt());
-    }
-  }
-
-  /**
-   * Stores values in cache and returns its hash.
-   * @param values - The values to store.
-   * @returns The hash of the values.
-   */
-  public store(values: Fr[], hash: Fr) {
-    this.cache.set(hash.toBigInt(), values);
-  }
-}

package/src/private/index.ts

@@ -1,19 +0,0 @@
-export { AcirSimulator } from './simulator.js';
-export {
-  type ExecutionDataProvider,
-  ContractClassNotFoundError,
-  ContractNotFoundError,
-} from './execution_data_provider.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 { executePrivateFunction } from './private_execution.js';
-export { PrivateExecutionOracle } from './private_execution_oracle.js';
-export { UtilityExecutionOracle } from './utility_execution_oracle.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';
-export { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';

package/src/private/message_load_oracle_inputs.ts

@@ -1,23 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { SiblingPath } from '@aztec/foundation/trees';
-
-export class MessageLoadOracleInputs<N extends number> {
-  constructor(
-    /** The index of the message commitment in the merkle tree. */
-    public index: bigint,
-    /** The path in the merkle tree to the message. */
-    public siblingPath: SiblingPath<N>,
-  ) {}
-
-  toFields(): Fr[] {
-    return [new Fr(this.index), ...this.siblingPath.toFields()];
-  }
-
-  /**
-   * Returns a representation of the public data witness as expected by intrinsic Noir deserialization.
-   */
-  public toNoirRepresentation(): (string | string[])[] {
-    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
-    return [new Fr(this.index).toString() as string, this.siblingPath.toFields().map(fr => fr.toString()) as string[]];
-  }
-}

package/src/private/pick_notes.ts

@@ -1,141 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { Comparator, type Note } from '@aztec/stdlib/note';
-
-export interface PropertySelector {
-  index: number;
-  offset: number;
-  length: number;
-}
-
-/**
- * Configuration for selecting values.
- */
-export interface Select {
-  /**
-   * Selector of the field to select and match.
-   */
-  selector: PropertySelector;
-  /**
-   * Required value of the field.
-   */
-  value: Fr;
-  /**
-   * The comparator to use
-   */
-  comparator: Comparator;
-}
-
-/**
- * The order to sort an array.
- */
-export enum SortOrder {
-  NADA = 0,
-  DESC = 1,
-  ASC = 2,
-}
-
-/**
- * Configuration for sorting values.
- */
-export interface Sort {
-  /**
-   * Selector of the field to sort.
-   */
-  selector: PropertySelector;
-  /**
-   * Order to sort the field.
-   */
-  order: SortOrder;
-}
-
-/**
- * Options for picking items from an array of BasicNoteData.
- */
-interface GetOptions {
-  /**
-   * Configurations for selecting items.
-   * Default: empty array.
-   */
-  selects?: Select[];
-  /**
-   * Configurations for sorting items.
-   * Default: empty array.
-   */
-  sorts?: Sort[];
-  /**
-   * The number of items to retrieve per query.
-   * Default: 0. No limit.
-   */
-  limit?: number;
-  /**
-   * The starting index for pagination.
-   * Default: 0.
-   */
-  offset?: number;
-}
-
-/**
- * Data needed from to perform sort.
- */
-interface ContainsNote {
-  /**
-   * The note.
-   */
-  note: Note;
-}
-
-const selectPropertyFromPackedNoteContent = (noteData: Fr[], selector: PropertySelector): Fr => {
-  const noteValueBuffer = noteData[selector.index].toBuffer();
-  const noteValue = noteValueBuffer.subarray(selector.offset, selector.offset + selector.length);
-  return Fr.fromBuffer(noteValue);
-};
-
-const selectNotes = <T extends ContainsNote>(noteDatas: T[], selects: Select[]): T[] =>
-  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: Fr[], b: Fr[], sorts: Sort[], level = 0): number => {
-  if (sorts[level] === undefined) {
-    return 0;
-  }
-
-  const { selector, order } = sorts[level];
-  if (order === (0 as SortOrder)) {
-    return 0;
-  }
-
-  const aValue = selectPropertyFromPackedNoteContent(a, selector);
-  const bValue = selectPropertyFromPackedNoteContent(b, selector);
-
-  const dir = order === (1 as SortOrder) ? [-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<T extends ContainsNote>(
-  noteDatas: T[],
-  { selects = [], sorts = [], limit = 0, offset = 0 }: GetOptions,
-): T[] {
-  return selectNotes(noteDatas, selects)
-    .sort((a, b) => sortNotes(a.note.items, b.note.items, sorts))
-    .slice(offset, limit ? offset + limit : undefined);
-}

package/src/private/private_execution.ts

@@ -1,160 +0,0 @@
-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 {
-  type FunctionArtifact,
-  type FunctionArtifactWithContractName,
-  type FunctionSelector,
-  countArgumentsSize,
-} 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 { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
-import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
-import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
-
-import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
-import { witnessMapToFields } from './acvm/deserialize.js';
-import { type ACVMWitness, Oracle, extractCallStack } from './acvm/index.js';
-import type { ExecutionDataProvider } from './execution_data_provider.js';
-import type { PrivateExecutionOracle } from './private_execution_oracle.js';
-import type { SimulationProvider } from './providers/simulation_provider.js';
-
-/**
- * Execute a private function and return the execution result.
- */
-export async function executePrivateFunction(
-  simulator: SimulationProvider,
-  privateExecutionOracle: PrivateExecutionOracle,
-  artifact: FunctionArtifactWithContractName,
-  contractAddress: AztecAddress,
-  functionSelector: FunctionSelector,
-  log = createLogger('simulator:private_execution'),
-): Promise<PrivateCallExecutionResult> {
-  const functionName = await privateExecutionOracle.getDebugFunctionName();
-  log.verbose(`Executing private function ${functionName}`, { contract: contractAddress });
-  const initialWitness = privateExecutionOracle.getInitialWitness(artifact);
-  const acvmCallback = new Oracle(privateExecutionOracle);
-  const timer = new Timer();
-  const acirExecutionResult = await simulator
-    .executeUserCircuit(initialWitness, artifact, acvmCallback)
-    .catch((err: Error) => {
-      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,
-  } satisfies CircuitWitnessGenerationStats);
-
-  const contractClassLogs = privateExecutionOracle.getContractClassLogs();
-
-  const rawReturnValues = await privateExecutionOracle.loadFromExecutionCache(publicInputs.returnsHash);
-
-  const noteHashLeafIndexMap = privateExecutionOracle.getNoteHashLeafIndexMap();
-  const newNotes = privateExecutionOracle.getNewNotes();
-  const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
-  const nestedExecutions = privateExecutionOracle.getNestedExecutions();
-
-  log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
-
-  return new PrivateCallExecutionResult(
-    artifact.bytecode,
-    Buffer.from(artifact.verificationKey!, 'base64'),
-    partialWitness,
-    publicInputs,
-    noteHashLeafIndexMap,
-    newNotes,
-    noteHashNullifierCounterMap,
-    rawReturnValues,
-    nestedExecutions,
-    contractClassLogs,
-    {
-      timings: {
-        witgen:
-          // Due to the recursive nature of execution, we have to subtract the time taken by the first level of
-          // child executions
-          duration - nestedExecutions.reduce((acc, nested) => acc + (nested.profileResult?.timings.witgen ?? 0), 0),
-        oracles: acirExecutionResult.oracles,
-      },
-    },
-  );
-}
-
-/**
- * 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: FunctionArtifact,
-  partialWitness: ACVMWitness,
-): PrivateCircuitPublicInputs {
-  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(Fr.fromString(returnedField));
-  }
-  return PrivateCircuitPublicInputs.fromFields(returnData);
-}
-
-export async function readCurrentClassId(
-  contractAddress: AztecAddress,
-  instance: ContractInstance,
-  executionDataProvider: ExecutionDataProvider | AztecNode,
-  blockNumber: number,
-) {
-  const { sharedMutableSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-  const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, slot =>
-    executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceDeployer, slot),
-  );
-  let currentClassId = sharedMutableValues.svc.getCurrentAt(blockNumber)[0];
-  if (currentClassId.isZero()) {
-    currentClassId = instance.originalContractClassId;
-  }
-  return currentClassId;
-}
-
-export async function verifyCurrentClassId(
-  contractAddress: AztecAddress,
-  executionDataProvider: ExecutionDataProvider,
-  blockNumber?: number,
-) {
-  const instance = await executionDataProvider.getContractInstance(contractAddress);
-  blockNumber = blockNumber ?? (await executionDataProvider.getBlockNumber());
-  const currentClassId = await readCurrentClassId(contractAddress, instance, executionDataProvider, blockNumber);
-  if (!instance.currentContractClassId.equals(currentClassId)) {
-    throw new Error(
-      `Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`,
-    );
-  }
-}