@aztec/simulator 0.86.0 → 0.87.0

package/src/common/errors.ts

@@ -2,7 +2,14 @@ import type { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { RawAssertionPayload } from '@aztec/noir-acvm_js';
 import { abiDecodeError } from '@aztec/noir-noirc_abi';
-import type { BrilligFunctionId, FunctionAbi, FunctionDebugMetadata, OpcodeLocation } from '@aztec/stdlib/abi';
+import type {
+  BrilligFunctionId,
+  DebugFileMap,
+  DebugInfo,
+  FunctionAbi,
+  LocationNodeDebugInfo,
+  OpcodeLocation,
+} from '@aztec/stdlib/abi';
 import {
   type FailingFunction,
   type NoirCallStack,
@@ -76,38 +83,42 @@ export function createSimulationError(error: Error, revertData?: Fr[]): Simulati
 }
 
 /**
- * Extracts a brillig location from an opcode location.
- * @param opcodeLocation - The opcode location to extract from. It should be in the format `acirLocation.brilligLocation` or `acirLocation`.
- * @returns The brillig location if the opcode location contains one.
- */
-function extractBrilligLocation(opcodeLocation: string): string | undefined {
-  const splitted = opcodeLocation.split('.');
-  if (splitted.length === 2) {
-    return splitted[1];
-  }
-  return undefined;
-}
-
-/**
- * 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.
+ * Resolves the source code locations from an array of opcode locations
  */
-function getSourceCodeLocationsFromOpcodeLocation(
-  opcodeLocation: string,
-  debug: FunctionDebugMetadata,
+export function resolveOpcodeLocations(
+  opcodeLocations: OpcodeLocation[],
+  debug: DebugInfo,
+  files: DebugFileMap,
   brilligFunctionId?: BrilligFunctionId,
 ): SourceCodeLocation[] {
-  const { debugSymbols, files } = debug;
+  let locations = opcodeLocations.flatMap(opcodeLocation =>
+    getSourceCodeLocationsFromOpcodeLocation(opcodeLocation, debug, files, brilligFunctionId),
+  );
 
-  let callStack = debugSymbols.locations[opcodeLocation] || [];
-  if (callStack.length === 0) {
-    const brilligLocation = extractBrilligLocation(opcodeLocation);
-    if (brilligFunctionId !== undefined && brilligLocation !== undefined) {
-      callStack = debugSymbols.brillig_locations[brilligFunctionId][brilligLocation] || [];
+  // Adds the acir call stack if the last location is a brillig opcode
+  if (locations.length > 0) {
+    const decomposedOpcodeLocation = opcodeLocations[opcodeLocations.length - 1].split('.');
+    if (decomposedOpcodeLocation.length === 2) {
+      const acirCallstackId = debug.acir_locations[decomposedOpcodeLocation[0]];
+      if (acirCallstackId !== undefined) {
+        const callStack = debug.location_tree.locations[acirCallstackId];
+        const acirCallstack = getCallStackFromLocationNode(callStack, debug.location_tree.locations, files);
+        locations = acirCallstack.concat(locations);
+      }
     }
   }
-  return callStack.map(call => {
-    const { file: fileId, span } = call;
+  return locations;
+}
+
+function getCallStackFromLocationNode(
+  callStack: LocationNodeDebugInfo,
+  locationTree: LocationNodeDebugInfo[],
+  files: DebugFileMap,
+): SourceCodeLocation[] {
+  const result: SourceCodeLocation[] = [];
+
+  while (callStack.parent !== null) {
+    const { file: fileId, span } = callStack.value;
 
     const { path, source } = files[fileId];
 
@@ -118,30 +129,55 @@ function getSourceCodeLocationsFromOpcodeLocation(
     const line = previousLines.length;
     const column = previousLines[previousLines.length - 1].length + 1;
 
-    return {
+    // Unshift since we are exploring child nodes first
+    result.unshift({
       filePath: path,
       line,
       column,
       fileSource: source,
       locationText,
-    };
-  });
-}
+    });
 
+    callStack = locationTree[callStack.parent];
+  }
+
+  return result;
+}
 /**
- * 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.
+ * 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.
  */
-export function resolveOpcodeLocations(
-  opcodeLocations: OpcodeLocation[],
-  debug: FunctionDebugMetadata,
+function getSourceCodeLocationsFromOpcodeLocation(
+  opcodeLocation: string,
+  debug: DebugInfo,
+  files: DebugFileMap,
   brilligFunctionId?: BrilligFunctionId,
 ): SourceCodeLocation[] {
-  return opcodeLocations.flatMap(opcodeLocation =>
-    getSourceCodeLocationsFromOpcodeLocation(opcodeLocation, debug, brilligFunctionId),
-  );
+  let callStackID = debug.acir_locations[opcodeLocation];
+  const brilligLocation = extractBrilligLocation(opcodeLocation);
+  if (brilligFunctionId !== undefined && brilligLocation !== undefined) {
+    callStackID = debug.brillig_locations[brilligFunctionId][brilligLocation];
+    if (callStackID === undefined) {
+      return [];
+    }
+  }
+
+  if (callStackID === undefined) {
+    return [];
+  }
+  const callStack = debug.location_tree.locations[callStackID];
+  return getCallStackFromLocationNode(callStack, debug.location_tree.locations, files);
+}
+
+/**
+ * Extracts a brillig location from an opcode location.
+ */
+function extractBrilligLocation(opcodeLocation: string): string | undefined {
+  const splitted = opcodeLocation.split('.');
+  if (splitted.length === 2) {
+    return splitted[1];
+  }
+  return undefined;
 }
 
 export function resolveAssertionMessage(errorPayload: RawAssertionPayload, abi: FunctionAbi): string | undefined {

package/src/private/acvm/acvm.ts

@@ -103,8 +103,8 @@ export function extractCallStack(
   }
 
   try {
-    return resolveOpcodeLocations(callStack, debug, brilligFunctionId);
-  } catch (err) {
+    return resolveOpcodeLocations(callStack, debug.debugSymbols, debug.files, brilligFunctionId);
+  } catch {
     return callStack;
   }
 }

package/src/private/acvm/oracle/oracle.ts

@@ -1,13 +1,18 @@
 import { Fr, Point } from '@aztec/foundation/fields';
 import { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { ContractClassLog, LogWithTxData } from '@aztec/stdlib/logs';
+import { ContractClassLog, ContractClassLogFields, LogWithTxData } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { ACVMField } from '../acvm_types.js';
 import { fromBoundedVec, fromUintArray, fromUintBoundedVec } from '../deserialize.js';
-import { bufferToBoundedVec, toACVMField, toACVMFieldSingleOrArray } from '../serialize.js';
+import {
+  arrayOfArraysToBoundedVecOfArrays,
+  bufferToBoundedVec,
+  toACVMField,
+  toACVMFieldSingleOrArray,
+} from '../serialize.js';
 import type { TypedOracle } from './typed_oracle.js';
 
 /**
@@ -169,8 +174,9 @@ export class Oracle {
     [limit]: ACVMField[],
     [offset]: ACVMField[],
     [status]: ACVMField[],
-    [returnSize]: ACVMField[],
-  ): Promise<ACVMField[][]> {
+    [maxNotes]: ACVMField[],
+    [packedRetrievedNoteLength]: ACVMField[],
+  ): Promise<(ACVMField | ACVMField[])[]> {
     const noteDatas = await this.typedOracle.getNotes(
       Fr.fromString(storageSlot),
       +numSelects,
@@ -188,32 +194,30 @@ export class Oracle {
       +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.');
+    if (noteDatas.length > 0) {
+      const noteLength = noteDatas[0].note.items.length;
+      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}.`);
-    }
+    // The expected return type is a BoundedVec<[Field; packedRetrievedNoteLength], maxNotes> where each
+    // array is structured as [contract_address, nonce, nonzero_note_hash_counter, ...packed_note].
 
-    const paddedZeros = Array(returnFieldSize - returnData.length).fill(toACVMField(0));
-    return [returnData.concat(paddedZeros)];
+    const returnDataAsArrayOfArrays = noteDatas.map(({ contractAddress, nonce, index, note }) => {
+      // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
+      const noteIsTransient = index === undefined;
+      const nonzeroNoteHashCounter = noteIsTransient ? true : false;
+      // If you change the array on the next line you have to change the `unpack_retrieved_note` function in
+      // `aztec/src/note/retrieved_note.nr`
+      return [contractAddress, nonce, nonzeroNoteHashCounter, ...note.items];
+    });
+
+    // Now we convert each sub-array to an array of ACVMField
+    const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfArrays.map(subArray => subArray.map(toACVMField));
+
+    // At last we convert the array of arrays to a bounded vec of arrays
+    return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedRetrievedNoteLength);
   }
 
   notifyCreatedNote(
@@ -288,10 +292,11 @@ export class Oracle {
   notifyCreatedContractClassLog(
     [contractAddress]: ACVMField[],
     message: ACVMField[],
+    [length]: ACVMField[],
     [counter]: ACVMField[],
   ): Promise<ACVMField[]> {
-    const logPayload = message.map(Fr.fromString);
-    const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logPayload);
+    const logFields = new ContractClassLogFields(message.map(Fr.fromString));
+    const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
 
     this.typedOracle.notifyCreatedContractClassLog(log, +counter);
     return Promise.resolve([]);
@@ -351,8 +356,10 @@ export class Oracle {
     return [];
   }
 
-  notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
-    this.typedOracle.notifySetMinRevertibleSideEffectCounter(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
+  async notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
+    await this.typedOracle.notifySetMinRevertibleSideEffectCounter(
+      Fr.fromString(minRevertibleSideEffectCounter).toNumber(),
+    );
     return Promise.resolve([]);
   }
 

package/src/private/acvm/oracle/typed_oracle.ts

@@ -198,7 +198,7 @@ export abstract class TypedOracle {
     return Promise.reject(new OracleMethodNotAvailableError('notifySetPublicTeardownFunctionCall'));
   }
 
-  notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): void {
+  notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): Promise<void> {
     throw new OracleMethodNotAvailableError('notifySetMinRevertibleSideEffectCounter');
   }
 

package/src/private/acvm/serialize.ts

@@ -86,3 +86,38 @@ export function arrayToBoundedVec(bVecStorage: ACVMField[], maxLen: number): [AC
   const len = toACVMField(BigInt(bVecStorage.length));
   return [storage, len];
 }
+
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */
+export function arrayOfArraysToBoundedVecOfArrays(
+  bVecStorage: ACVMField[][],
+  maxLen: number,
+  nestedArrayLength: number,
+): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+
+  // Check that all nested arrays have length nestedArrayLength
+  if (!bVecStorage.every(nestedArray => nestedArray.length === nestedArrayLength)) {
+    throw new Error(
+      `Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`,
+    );
+  }
+
+  // Flatten the array of arrays
+  const flattenedStorage = bVecStorage.flat();
+
+  // Calculate and add padding
+  const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+  const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(toACVMField(BigInt(0))));
+
+  // Return flattened array with padding and length
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [flattenedStorageWithPadding, len];
+}

package/src/private/index.ts

@@ -9,6 +9,9 @@ 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';

package/src/private/pick_notes.ts

@@ -113,19 +113,19 @@ const sortNotes = (a: Fr[], b: Fr[], sorts: Sort[], level = 0): number => {
   }
 
   const { selector, order } = sorts[level];
-  if (order === 0) {
+  if (order === (0 as SortOrder)) {
     return 0;
   }
 
   const aValue = selectPropertyFromPackedNoteContent(a, selector);
   const bValue = selectPropertyFromPackedNoteContent(b, selector);
 
-  const dir = order === 1 ? [-1, 1] : [1, -1];
+  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];
+      ? dir[0]
+      : dir[1];
 };
 
 /**

package/src/private/private_execution.ts

@@ -91,6 +91,14 @@ export async function executePrivateFunction(
     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),
+      },
+    },
   );
 }
 

package/src/private/providers/acvm_native.ts

@@ -78,7 +78,7 @@ export async function executeNativeCircuit(
   try {
     // Check that the directory exists
     await fs.access(workingDirectory);
-  } catch (error) {
+  } catch {
     return { status: ACVM_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
@@ -138,7 +138,11 @@ export async function executeNativeCircuit(
 }
 
 export class NativeACVMSimulator implements SimulationProvider {
-  constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
+  constructor(
+    private workingDirectory: string,
+    private pathToAcvm: string,
+    private witnessFilename?: string,
+  ) {}
 
   async executeProtocolCircuit(
     input: ACVMWitness,

package/src/private/providers/simulation_provider.ts

@@ -46,25 +46,23 @@ export type DecodedError = ExecutionError & { decodedAssertionPayload?: any; noi
 // Payload parsing taken from noir/noir-repo/tooling/noir_js/src/witness_generation.ts.
 // TODO: import this in isolation without having to import noir_js in its entirety.
 export function enrichNoirError(artifact: NoirCompiledCircuit, originalError: ExecutionError): DecodedError {
-  const payload = originalError.rawAssertionPayload;
-  if (!payload) {
-    return originalError;
-  }
   const enrichedError = originalError as DecodedError;
 
-  try {
-    // Decode the payload
-    const decodedPayload = abiDecodeError(artifact.abi, payload);
+  if (originalError.rawAssertionPayload) {
+    try {
+      // Decode the payload
+      const decodedPayload = abiDecodeError(artifact.abi, originalError.rawAssertionPayload);
 
-    if (typeof decodedPayload === 'string') {
-      // If it's a string, just add it to the error message
-      enrichedError.message = `Circuit execution failed: ${decodedPayload}`;
-    } else {
-      // If not, attach the payload to the original error
-      enrichedError.decodedAssertionPayload = decodedPayload;
+      if (typeof decodedPayload === 'string') {
+        // If it's a string, just add it to the error message
+        enrichedError.message = `Circuit execution failed: ${decodedPayload}`;
+      } else {
+        // If not, attach the payload to the original error
+        enrichedError.decodedAssertionPayload = decodedPayload;
+      }
+    } catch {
+      // Ignore errors decoding the payload
     }
-  } catch (_errorDecoding) {
-    // Ignore errors decoding the payload
   }
 
   try {
@@ -84,7 +82,7 @@ export function enrichNoirError(artifact: NoirCompiledCircuit, originalError: Ex
         return `at ${errorLocation.locationText} (${errorLocation.filePath}:${errorLocation.line}:${errorLocation.column})`;
       }
     });
-  } catch (_errorResolving) {
+  } catch {
     // Ignore errors resolving the callstack
   }
 

package/src/private/simulator.ts

@@ -22,7 +22,10 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
 export class AcirSimulator {
   private log: Logger;
 
-  constructor(private executionDataProvider: ExecutionDataProvider, private simulationProvider: SimulationProvider) {
+  constructor(
+    private executionDataProvider: ExecutionDataProvider,
+    private simulationProvider: SimulationProvider,
+  ) {
     this.log = createLogger('simulator');
   }
 

package/src/public/avm/avm_contract_call_result.ts

@@ -25,7 +25,7 @@ export class AvmContractCallResult {
       this.gasLeft,
     )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
-      resultsStr += `, revertReason: ${this.revertReason}`;
+      resultsStr += `, revertReason: ${this.revertReason.message}`;
     }
     return resultsStr;
   }
@@ -60,7 +60,7 @@ export class AvmFinalizedCallResult {
       this.gasLeft,
     )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
-      resultsStr += `, revertReason: ${this.revertReason}`;
+      resultsStr += `, revertReason: ${this.revertReason.message}`;
     }
     return resultsStr;
   }

package/src/public/avm/avm_execution_environment.ts

@@ -15,9 +15,14 @@ export class AvmExecutionEnvironment {
     public readonly globals: GlobalVariables,
     public readonly isStaticCall: boolean,
     public readonly calldata: Fr[],
+    public readonly clientInitiatedSimulation: boolean = false,
   ) {}
 
-  private deriveEnvironmentForNestedCallInternal(targetAddress: AztecAddress, calldata: Fr[], isStaticCall: boolean) {
+  private deriveEnvironmentForNestedCallInternal(
+    targetAddress: AztecAddress,
+    calldata: Fr[],
+    isStaticCall: boolean,
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
       /*address=*/ targetAddress,
       /*sender=*/ this.address,
@@ -26,6 +31,7 @@ export class AvmExecutionEnvironment {
       this.globals,
       isStaticCall,
       calldata,
+      /*clientInitiatedSimulation=*/ this.clientInitiatedSimulation,
     );
   }
 

package/src/public/avm/avm_gas.ts

@@ -2,7 +2,6 @@ import * as c from '@aztec/constants';
 
 import { TypeTag } from './avm_memory_types.js';
 import { InstructionExecutionError } from './errors.js';
-import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 import { Opcode } from './serialization/instruction_serialization.js';
 
 /** Gas counters in L1, L2, and DA. */
@@ -136,7 +135,6 @@ const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.RETURN, makeCost(c.AVM_RETURN_DYN_L2_GAS, 0)],
   [Opcode.REVERT_8, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
   [Opcode.REVERT_16, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
-  [Opcode.DEBUGLOG, makeCost(c.AVM_DEBUGLOG_DYN_L2_GAS, 0)],
   [Opcode.TORADIXBE, makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)],
 ]);
 
@@ -149,24 +147,6 @@ export function getDynamicGasCost(opcode: Opcode): Gas {
   return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
 }
 
-/** Returns the gas cost associated with the memory operations performed. */
-export function getMemoryGasCost(args: { reads?: number; writes?: number; indirect?: number }) {
-  const { reads, writes, indirect } = args;
-  const indirectCount = Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
-  const l2MemoryGasCost =
-    (reads ?? 0) * GAS_COST_CONSTANTS.MEMORY_READ +
-    (writes ?? 0) * GAS_COST_CONSTANTS.MEMORY_WRITE +
-    indirectCount * GAS_COST_CONSTANTS.MEMORY_INDIRECT_READ_PENALTY;
-  return makeGas({ l2Gas: l2MemoryGasCost });
-}
-
-/** Constants used in base cost calculations. */
-export const GAS_COST_CONSTANTS = {
-  MEMORY_READ: 10,
-  MEMORY_INDIRECT_READ_PENALTY: 10,
-  MEMORY_WRITE: 100,
-};
-
 /** Returns gas cost for an operation on a given type tag based on the base cost per byte. */
 export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
   return mulGas(baseCost, getGasCostMultiplierFromTypeTag(tag));

package/src/public/avm/avm_simulator.ts

@@ -79,6 +79,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
     isStaticCall: boolean,
     calldata: Fr[],
     allocatedGas: Gas,
+    clientInitiatedSimulation: boolean = false,
   ) {
     const avmExecutionEnv = new AvmExecutionEnvironment(
       address,
@@ -88,6 +89,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
       globals,
       isStaticCall,
       calldata,
+      clientInitiatedSimulation,
     );
 
     const avmMachineState = new AvmMachineState(allocatedGas);
@@ -108,7 +110,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
         throw err;
       }
       return await this.handleFailureToRetrieveBytecode(
-        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err}. Reverting...`,
+        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err.message}. Reverting...`,
       );
     }
 

package/src/public/avm/fixtures/initializers.ts

@@ -71,6 +71,7 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.calldata ?? [],
+    overrides?.clientInitiatedSimulation ?? true, // default to true for testing even though internal default is false
   );
 }
 

package/src/public/avm/fixtures/utils.ts

@@ -1,7 +1,5 @@
 import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { AvmGadgetsTestContract } from '@aztec/noir-contracts.js/AvmGadgetsTest';
-import { AvmTestContract } from '@aztec/noir-contracts.js/AvmTest';
 import {
   type ContractArtifact,
   type FunctionAbi,
@@ -98,70 +96,6 @@ export function resolveContractAssertionMessage(
   return resolveAssertionMessageFromRevertData(output, functionArtifact);
 }
 
-export function getAvmTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
-  return getFunctionSelector(functionName, AvmTestContract.artifactForPublic);
-}
-
-export function getAvmGadgetsTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
-  const artifact = getAllFunctionAbis(AvmGadgetsTestContract.artifactForPublic).find(f => f.name === functionName)!;
-  assert(!!artifact, `Function ${functionName} not found in AvmGadgetsTestContractArtifact`);
-  const params = artifact.parameters;
-  return FunctionSelector.fromNameAndParameters(artifact.name, params);
-}
-
-export function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
-  const artifact = getContractFunctionArtifact(functionName, AvmTestContract.artifactForPublic) as FunctionArtifact;
-  assert(
-    !!artifact?.bytecode,
-    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
-  );
-  return artifact;
-}
-
-export function getAvmGadgetsTestContractArtifact(functionName: string): FunctionArtifact {
-  const artifact = AvmGadgetsTestContract.artifactForPublic.functions.find(f => f.name === functionName)!;
-  assert(
-    !!artifact?.bytecode,
-    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
-  );
-  return artifact;
-}
-
-export function getAvmTestContractBytecode(functionName: string): Buffer {
-  const artifact = getAvmTestContractArtifact(functionName);
-  return artifact.bytecode;
-}
-
-export function getAvmGadgetsTestContractBytecode(functionName: string): Buffer {
-  const artifact = getAvmGadgetsTestContractArtifact(functionName);
-  return artifact.bytecode;
-}
-
-export function resolveAvmTestContractAssertionMessage(
-  functionName: string,
-  revertReason: AvmRevertReason,
-  output: Fr[],
-): string | undefined {
-  return resolveContractAssertionMessage(functionName, revertReason, output, AvmTestContract.artifactForPublic);
-}
-
-export function resolveAvmGadgetsTestContractAssertionMessage(
-  functionName: string,
-  revertReason: AvmRevertReason,
-  output: Fr[],
-): string | undefined {
-  traverseCauseChain(revertReason, cause => {
-    revertReason = cause as AvmRevertReason;
-  });
-
-  const functionArtifact = AvmGadgetsTestContract.artifactForPublic.functions.find(f => f.name === functionName);
-  if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
-    return undefined;
-  }
-
-  return resolveAssertionMessageFromRevertData(output, functionArtifact);
-}
-
 /**
  * Create a contract class and instance given constructor args, artifact, etc.
  * NOTE: This is useful for testing real-ish contract class registration and instance deployment TXs (via logs)