@aztec/simulator 0.23.0 → 0.26.1

package/src/client/simulator.ts

@@ -0,0 +1,317 @@
+import { AztecNode, FunctionCall, Note, TxExecutionRequest } from '@aztec/circuit-types';
+import { CallContext, FunctionData } from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import {
+  ArrayType,
+  FunctionArtifactWithDebugMetadata,
+  FunctionSelector,
+  FunctionType,
+  encodeArguments,
+} from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+
+import { WasmBlackBoxFunctionSolver, createBlackBoxSolver } from '@noir-lang/acvm_js';
+
+import { createSimulationError } from '../common/errors.js';
+import { PackedArgsCache } from '../common/packed_args_cache.js';
+import { ClientExecutionContext } from './client_execution_context.js';
+import { DBOracle } from './db_oracle.js';
+import { ExecutionNoteCache } from './execution_note_cache.js';
+import { ExecutionResult } from './execution_result.js';
+import { executePrivateFunction } from './private_execution.js';
+import { executeUnconstrainedFunction } from './unconstrained_execution.js';
+import { ViewDataOracle } from './view_data_oracle.js';
+
+/**
+ * The ACIR simulator.
+ */
+export class AcirSimulator {
+  private static solver: Promise<WasmBlackBoxFunctionSolver>; // ACVM's backend
+  private log: DebugLogger;
+
+  constructor(private db: DBOracle, private node: AztecNode) {
+    this.log = createDebugLogger('aztec:simulator');
+  }
+
+  /**
+   * Gets or initializes the ACVM WasmBlackBoxFunctionSolver.
+   *
+   * @remarks
+   *
+   * Occurs only once across all instances of AcirSimulator.
+   * Speeds up execution by only performing setup tasks (like pedersen
+   * generator initialization) one time.
+   * TODO(https://github.com/AztecProtocol/aztec-packages/issues/1627):
+   * determine whether this requires a lock
+   *
+   * @returns ACVM WasmBlackBoxFunctionSolver
+   */
+  public static getSolver(): Promise<WasmBlackBoxFunctionSolver> {
+    if (!this.solver) {
+      this.solver = createBlackBoxSolver();
+    }
+    return this.solver;
+  }
+
+  /**
+   * Runs a private function.
+   * @param request - The transaction request.
+   * @param entryPointArtifact - The artifact of the entry point function.
+   * @param contractAddress - The address of the contract (should match request.origin)
+   * @param portalContractAddress - The address of the portal contract.
+   * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract or a specific account.
+   * @returns The result of the execution.
+   */
+  public async run(
+    request: TxExecutionRequest,
+    entryPointArtifact: FunctionArtifactWithDebugMetadata,
+    contractAddress: AztecAddress,
+    portalContractAddress: EthAddress,
+    msgSender = AztecAddress.ZERO,
+  ): Promise<ExecutionResult> {
+    if (entryPointArtifact.functionType !== FunctionType.SECRET) {
+      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as secret`);
+    }
+
+    if (request.origin !== contractAddress) {
+      this.log.warn(
+        `Request origin does not match contract address in simulation. Request origin: ${request.origin}, contract address: ${contractAddress}`,
+      );
+    }
+
+    const curve = new Grumpkin();
+
+    const header = await this.db.getHeader();
+    const callContext = new CallContext(
+      msgSender,
+      contractAddress,
+      portalContractAddress,
+      FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
+      false,
+      false,
+      request.functionData.isConstructor,
+      // TODO: when contract deployment is done in-app, we should only reserve one counter for the tx hash
+      // 2 counters are reserved for tx hash and contract deployment nullifier
+      request.txContext.isContractDeploymentTx ? 2 : 1,
+    );
+    const context = new ClientExecutionContext(
+      contractAddress,
+      request.argsHash,
+      request.txContext,
+      callContext,
+      header,
+      request.authWitnesses,
+      PackedArgsCache.create(request.packedArguments),
+      new ExecutionNoteCache(),
+      this.db,
+      curve,
+      this.node,
+    );
+
+    try {
+      const executionResult = await executePrivateFunction(
+        context,
+        entryPointArtifact,
+        contractAddress,
+        request.functionData,
+      );
+      return executionResult;
+    } catch (err) {
+      throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
+    }
+  }
+
+  /**
+   * Runs an unconstrained function.
+   * @param request - The transaction request.
+   * @param entryPointArtifact - The artifact of the entry point function.
+   * @param contractAddress - The address of the contract.
+   * @param aztecNode - The AztecNode instance.
+   */
+  public async runUnconstrained(
+    request: FunctionCall,
+    entryPointArtifact: FunctionArtifactWithDebugMetadata,
+    contractAddress: AztecAddress,
+  ) {
+    if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
+      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as constrained`);
+    }
+
+    const context = new ViewDataOracle(contractAddress, [], this.db, this.node);
+
+    try {
+      return await executeUnconstrainedFunction(
+        context,
+        entryPointArtifact,
+        contractAddress,
+        request.functionData,
+        request.args,
+      );
+    } catch (err) {
+      throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
+    }
+  }
+
+  /**
+   * Computes the inner nullifier of a note.
+   * @param contractAddress - The address of the contract.
+   * @param nonce - The nonce of the note hash.
+   * @param storageSlot - The storage slot.
+   * @param noteTypeId - The note type identifier.
+   * @param note - The note.
+   * @returns The nullifier.
+   */
+  public async computeNoteHashAndNullifier(
+    contractAddress: AztecAddress,
+    nonce: Fr,
+    storageSlot: Fr,
+    noteTypeId: Fr,
+    note: Note,
+  ) {
+    const artifact: FunctionArtifactWithDebugMetadata | undefined = await this.db.getFunctionArtifactByName(
+      contractAddress,
+      'compute_note_hash_and_nullifier',
+    );
+    if (!artifact) {
+      throw new Error(
+        `Mandatory implementation of "compute_note_hash_and_nullifier" missing in noir contract ${contractAddress.toString()}.`,
+      );
+    }
+
+    if (artifact.parameters.length != 5) {
+      throw new Error(
+        `Expected 5 parameters in mandatory implementation of "compute_note_hash_and_nullifier", but found ${
+          artifact.parameters.length
+        } in noir contract ${contractAddress.toString()}.`,
+      );
+    }
+
+    const maxNoteFields = (artifact.parameters[artifact.parameters.length - 1].type as ArrayType).length;
+    if (maxNoteFields < note.items.length) {
+      throw new Error(
+        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please consider increasing the allowed field size to accommodate all notes generated from the contract.`,
+      );
+    }
+
+    const extendedNoteItems = note.items.concat(Array(maxNoteFields - note.items.length).fill(Fr.ZERO));
+
+    const execRequest: FunctionCall = {
+      to: contractAddress,
+      functionData: FunctionData.empty(),
+      args: encodeArguments(artifact, [contractAddress, nonce, storageSlot, noteTypeId, extendedNoteItems]),
+    };
+
+    const [innerNoteHash, siloedNoteHash, uniqueSiloedNoteHash, innerNullifier] = (await this.runUnconstrained(
+      execRequest,
+      artifact,
+      contractAddress,
+    )) as bigint[];
+
+    return {
+      innerNoteHash: new Fr(innerNoteHash),
+      siloedNoteHash: new Fr(siloedNoteHash),
+      uniqueSiloedNoteHash: new Fr(uniqueSiloedNoteHash),
+      innerNullifier: new Fr(innerNullifier),
+    };
+  }
+
+  /**
+   * Computes the inner note hash of a note, which contains storage slot and the custom note hash.
+   * @param contractAddress - The address of the contract.
+   * @param storageSlot - The storage slot.
+   * @param noteTypeId - The note type identifier.
+   * @param note - The note.
+   * @returns The note hash.
+   */
+  public async computeInnerNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: Fr, note: Note) {
+    const { innerNoteHash } = await this.computeNoteHashAndNullifier(
+      contractAddress,
+      Fr.ZERO,
+      storageSlot,
+      noteTypeId,
+      note,
+    );
+    return innerNoteHash;
+  }
+
+  /**
+   * Computes the unique note hash of a note.
+   * @param contractAddress - The address of the contract.
+   * @param nonce - The nonce of the note hash.
+   * @param storageSlot - The storage slot.
+   * @param noteTypeId - The note type identifier.
+   * @param note - The note.
+   * @returns The note hash.
+   */
+  public async computeUniqueSiloedNoteHash(
+    contractAddress: AztecAddress,
+    nonce: Fr,
+    storageSlot: Fr,
+    noteTypeId: Fr,
+    note: Note,
+  ) {
+    const { uniqueSiloedNoteHash } = await this.computeNoteHashAndNullifier(
+      contractAddress,
+      nonce,
+      storageSlot,
+      noteTypeId,
+      note,
+    );
+    return uniqueSiloedNoteHash;
+  }
+
+  /**
+   * Computes the siloed note hash of a note.
+   * @param contractAddress - The address of the contract.
+   * @param nonce - The nonce of the note hash.
+   * @param storageSlot - The storage slot.
+   * @param noteTypeId - The note type identifier.
+   * @param note - The note.
+   * @returns The note hash.
+   */
+  public async computeSiloedNoteHash(
+    contractAddress: AztecAddress,
+    nonce: Fr,
+    storageSlot: Fr,
+    noteTypeId: Fr,
+    note: Note,
+  ) {
+    const { siloedNoteHash } = await this.computeNoteHashAndNullifier(
+      contractAddress,
+      nonce,
+      storageSlot,
+      noteTypeId,
+      note,
+    );
+    return siloedNoteHash;
+  }
+
+  /**
+   * Computes the inner note hash of a note, which contains storage slot and the custom note hash.
+   * @param contractAddress - The address of the contract.
+   * @param nonce - The nonce of the unique note hash.
+   * @param storageSlot - The storage slot.
+   * @param noteTypeId - The note type identifier.
+   * @param note - The note.
+   * @returns The note hash.
+   */
+  public async computeInnerNullifier(
+    contractAddress: AztecAddress,
+    nonce: Fr,
+    storageSlot: Fr,
+    noteTypeId: Fr,
+    note: Note,
+  ) {
+    const { innerNullifier } = await this.computeNoteHashAndNullifier(
+      contractAddress,
+      nonce,
+      storageSlot,
+      noteTypeId,
+      note,
+    );
+    return innerNullifier;
+  }
+}

package/src/client/unconstrained_execution.ts

@@ -0,0 +1,49 @@
+import { FunctionData } from '@aztec/circuits.js';
+import { DecodedReturn, FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import { extractReturnWitness } from '../acvm/deserialize.js';
+import { Oracle, acvm, extractCallStack, toACVMWitness } from '../acvm/index.js';
+import { ExecutionError } from '../common/errors.js';
+import { AcirSimulator } from './simulator.js';
+import { ViewDataOracle } from './view_data_oracle.js';
+
+// docs:start:execute_unconstrained_function
+/**
+ * Execute an unconstrained function and return the decoded values.
+ */
+export async function executeUnconstrainedFunction(
+  oracle: ViewDataOracle,
+  artifact: FunctionArtifactWithDebugMetadata,
+  contractAddress: AztecAddress,
+  functionData: FunctionData,
+  args: Fr[],
+  log = createDebugLogger('aztec:simulator:unconstrained_execution'),
+): Promise<DecodedReturn> {
+  const functionSelector = functionData.selector;
+  log(`Executing unconstrained function ${contractAddress}:${functionSelector}`);
+
+  const acir = Buffer.from(artifact.bytecode, 'base64');
+  const initialWitness = toACVMWitness(0, args);
+  const { partialWitness } = await acvm(
+    await AcirSimulator.getSolver(),
+    acir,
+    initialWitness,
+    new Oracle(oracle),
+  ).catch((err: Error) => {
+    throw new ExecutionError(
+      err.message,
+      {
+        contractAddress,
+        functionSelector,
+      },
+      extractCallStack(err, artifact.debug),
+      { cause: err },
+    );
+  });
+
+  return decodeReturnValues(artifact, extractReturnWitness(acir, partialWitness));
+}
+// docs:end:execute_unconstrained_function

package/src/client/view_data_oracle.ts

@@ -0,0 +1,253 @@
+import {
+  AuthWitness,
+  AztecNode,
+  CompleteAddress,
+  MerkleTreeId,
+  NoteStatus,
+  NullifierMembershipWitness,
+  PublicDataWitness,
+} from '@aztec/circuit-types';
+import { Header } from '@aztec/circuits.js';
+import { siloNullifier } from '@aztec/circuits.js/hash';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { ContractInstance } from '@aztec/types/contracts';
+
+import { NoteData, TypedOracle } from '../acvm/index.js';
+import { DBOracle } from './db_oracle.js';
+import { pickNotes } from './pick_notes.js';
+
+/**
+ * The execution context for a client view tx simulation.
+ * It only reads data from data sources. Nothing will be updated or created during this simulation.
+ */
+export class ViewDataOracle extends TypedOracle {
+  constructor(
+    protected readonly contractAddress: AztecAddress,
+    /** List of transient auth witnesses to be used during this simulation */
+    protected readonly authWitnesses: AuthWitness[],
+    protected readonly db: DBOracle,
+    protected readonly aztecNode: AztecNode,
+    protected log = createDebugLogger('aztec:simulator:client_view_context'),
+  ) {
+    super();
+  }
+
+  /**
+   * Return the nullifier key pair of an account to use in a specific contract.
+   * @param account - The account address of the nullifier key.
+   */
+  public getNullifierKeyPair(account: AztecAddress) {
+    return this.db.getNullifierKeyPair(account, this.contractAddress);
+  }
+
+  /**
+   * Fetches the index and sibling path of a leaf at a given block from a given tree.
+   * @param blockNumber - The block number at which to get the membership witness.
+   * @param treeId - Id of the tree to get the sibling path from.
+   * @param leafValue - The leaf value
+   * @returns The index and sibling path concatenated [index, sibling_path]
+   */
+  public async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+    const index = await this.db.findLeafIndex(blockNumber, treeId, leafValue);
+    if (!index) {
+      throw new Error(`Leaf value: ${leafValue} not found in ${MerkleTreeId[treeId]}`);
+    }
+    const siblingPath = await this.db.getSiblingPath(blockNumber, treeId, index);
+    return [new Fr(index), ...siblingPath];
+  }
+
+  /**
+   * Fetches a sibling path at a given block and index from a tree specified by `treeId`.
+   * @param blockNumber - The block number at which to get the membership witness.
+   * @param treeId - Id of the tree to get the sibling path from.
+   * @param leafIndex - Index of the leaf to get sibling path for
+   * @returns The sibling path.
+   */
+  public getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr): Promise<Fr[]> {
+    return this.db.getSiblingPath(blockNumber, treeId, leafIndex.toBigInt());
+  }
+
+  /**
+   * Returns a nullifier membership witness for a given nullifier at a given block.
+   * @param blockNumber - The block number at which to get the index.
+   * @param nullifier - Nullifier we try to find witness for.
+   * @returns The nullifier membership witness (if found).
+   */
+  public async getNullifierMembershipWitness(
+    blockNumber: number,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return await this.db.getNullifierMembershipWitness(blockNumber, nullifier);
+  }
+
+  /**
+   * Returns a low nullifier membership witness for a given nullifier at a given block.
+   * @param blockNumber - The block number at which to get the index.
+   * @param nullifier - Nullifier we try to find the low nullifier witness for.
+   * @returns The low nullifier membership witness (if found).
+   * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
+   * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
+   * we are trying to prove non-inclusion for.
+   */
+  public async getLowNullifierMembershipWitness(
+    blockNumber: number,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return await this.db.getLowNullifierMembershipWitness(blockNumber, nullifier);
+  }
+
+  /**
+   * Returns a public data tree witness for a given leaf slot at a given block.
+   * @param blockNumber - The block number at which to get the index.
+   * @param leafSlot - The slot of the public data tree to get the witness for.
+   * @returns - The witness
+   */
+  public async getPublicDataTreeWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    return await this.db.getPublicDataTreeWitness(blockNumber, leafSlot);
+  }
+
+  /**
+   * Fetches a block header of a given block.
+   * @param blockNumber - The number of a block of which to get the block header.
+   * @returns Block extracted from a block with block number `blockNumber`.
+   */
+  public async getHeader(blockNumber: number): Promise<Header | undefined> {
+    const block = await this.db.getBlock(blockNumber);
+    if (!block) {
+      return undefined;
+    }
+    return block.header;
+  }
+
+  /**
+   * Retrieve the complete address associated to a given address.
+   * @param address - Address to fetch the complete address for.
+   * @returns A complete address associated with the input address.
+   */
+  public getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
+    return this.db.getCompleteAddress(address);
+  }
+
+  /**
+   * Returns a contract instance associated with an address or throws if not found.
+   * @param address - Address.
+   * @returns A contract instance.
+   */
+  public getContractInstance(address: AztecAddress): Promise<ContractInstance> {
+    return this.db.getContractInstance(address);
+  }
+
+  /**
+   * Returns an auth witness for the given message hash. Checks on the list of transient witnesses
+   * for this transaction first, and falls back to the local database if not found.
+   * @param messageHash - Hash of the message to authenticate.
+   * @returns Authentication witness for the requested message hash.
+   */
+  public getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
+    return Promise.resolve(
+      this.authWitnesses.find(w => w.requestHash.equals(messageHash))?.witness ?? this.db.getAuthWitness(messageHash),
+    );
+  }
+
+  /**
+   * Pops a capsule from the capsule dispenser
+   * @returns The capsule values
+   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle.
+   */
+  public popCapsule(): Promise<Fr[]> {
+    return this.db.popCapsule();
+  }
+
+  /**
+   * Gets some notes for a contract address and storage slot.
+   * Returns a flattened array containing filtered notes.
+   *
+   * @remarks
+   * Check for pending notes with matching slot.
+   * Real notes coming from DB will have a leafIndex which
+   * represents their index in the note hash tree.
+   *
+   * @param storageSlot - The storage slot.
+   * @param numSelects - The number of valid selects in selectBy and selectValues.
+   * @param selectBy - An array of indices of the fields to selects.
+   * @param selectValues - The values to match.
+   * @param selectComparators - The comparators to use to match values.
+   * @param sortBy - An array of indices of the fields to sort.
+   * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
+   * @param limit - The number of notes to retrieve per query.
+   * @param offset - The starting index for pagination.
+   * @param status - The status of notes to fetch.
+   * @returns Array of note data.
+   */
+  public async getNotes(
+    storageSlot: Fr,
+    numSelects: number,
+    selectBy: number[],
+    selectValues: Fr[],
+    selectComparators: number[],
+    sortBy: number[],
+    sortOrder: number[],
+    limit: number,
+    offset: number,
+    status: NoteStatus,
+  ): Promise<NoteData[]> {
+    const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot, status);
+    return pickNotes<NoteData>(dbNotes, {
+      selects: selectBy
+        .slice(0, numSelects)
+        .map((index, i) => ({ index, value: selectValues[i], comparator: selectComparators[i] })),
+      sorts: sortBy.map((index, i) => ({ index, order: sortOrder[i] })),
+      limit,
+      offset,
+    });
+  }
+
+  /**
+   * Check if a nullifier exists in the nullifier tree.
+   * @param innerNullifier - The inner nullifier.
+   * @returns A boolean indicating whether the nullifier exists in the tree or not.
+   */
+  public async checkNullifierExists(innerNullifier: Fr) {
+    const nullifier = siloNullifier(this.contractAddress, innerNullifier!);
+    const index = await this.db.getNullifierIndex(nullifier);
+    return index !== undefined;
+  }
+
+  /**
+   * Fetches the a message from the db, given its key.
+   * @param entryKey - A buffer representing the entry key.
+   * @returns The l1 to l2 message data
+   */
+  public async getL1ToL2MembershipWitness(entryKey: Fr) {
+    return await this.db.getL1ToL2MembershipWitness(entryKey);
+  }
+
+  /**
+   * Retrieves the portal contract address associated with the given contract address.
+   * Throws an error if the input contract address is not found or invalid.
+   * @param contractAddress - The address of the contract whose portal address is to be fetched.
+   * @returns The portal contract address.
+   */
+  public getPortalContractAddress(contractAddress: AztecAddress) {
+    return this.db.getPortalContractAddress(contractAddress);
+  }
+
+  /**
+   * Read the public storage data.
+   * @param startStorageSlot - The starting storage slot.
+   * @param numberOfElements - Number of elements to read from the starting storage slot.
+   */
+  public async storageRead(startStorageSlot: Fr, numberOfElements: number) {
+    const values = [];
+    for (let i = 0n; i < numberOfElements; i++) {
+      const storageSlot = new Fr(startStorageSlot.value + i);
+      const value = await this.aztecNode.getPublicStorageAt(this.contractAddress, storageSlot);
+
+      this.log(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      values.push(value);
+    }
+    return values;
+  }
+}

package/src/common/errors.ts

@@ -0,0 +1,61 @@
+import { FailingFunction, NoirCallStack, SimulationError } from '@aztec/circuit-types';
+
+/**
+ * An error that occurred during the execution of a function.
+ */
+export class ExecutionError extends Error {
+  constructor(
+    message: string,
+    /**
+     * The function that failed.
+     */
+    public failingFunction: FailingFunction,
+    /**
+     * The noir call stack of the function that failed.
+     */
+    public noirCallStack?: NoirCallStack,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+  }
+}
+
+/**
+ * Traverses the cause chain of an error.
+ * @param error - The error to start from.
+ * @param callback - A callback on every error, including the first one.
+ */
+export function traverseCauseChain(error: Error, callback: (error: Error) => void) {
+  let currentError: Error | undefined = error;
+  while (currentError) {
+    callback(currentError);
+    if (currentError.cause && currentError.cause instanceof Error) {
+      currentError = currentError.cause;
+    } else {
+      currentError = undefined;
+    }
+  }
+}
+
+/**
+ * Creates a simulation error from an error chain generated during the execution of a function.
+ * @param error - The error thrown during execution.
+ * @returns - A simulation error.
+ */
+export function createSimulationError(error: Error): SimulationError {
+  let rootCause = error;
+  let noirCallStack: NoirCallStack | undefined = undefined;
+  const aztecCallStack: FailingFunction[] = [];
+
+  traverseCauseChain(error, cause => {
+    rootCause = cause;
+    if (cause instanceof ExecutionError) {
+      aztecCallStack.push(cause.failingFunction);
+      if (cause.noirCallStack) {
+        noirCallStack = cause.noirCallStack;
+      }
+    }
+  });
+
+  return new SimulationError(rootCause.message, aztecCallStack, noirCallStack, { cause: rootCause });
+}

package/src/common/index.ts

@@ -0,0 +1,3 @@
+export * from './packed_args_cache.js';
+export * from './errors.js';
+export * from './side_effect_counter.js';