@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/src/private/{providers/factory.ts → factory.ts}

@@ -4,14 +4,14 @@ import { promises as fs } from 'fs';
 
 import { NativeACVMSimulator } from './acvm_native.js';
 import { WASMSimulator } from './acvm_wasm.js';
-import type { SimulationProvider } from './simulation_provider.js';
+import type { CircuitSimulator } from './circuit_simulator.js';
 
-export type SimulationProviderConfig = {
+export type SimulatorConfig = {
   acvmBinaryPath?: string;
   acvmWorkingDirectory?: string;
 };
 
-export function getSimulationProviderConfigFromEnv() {
+export function getSimulatorConfigFromEnv() {
   const { ACVM_BINARY_PATH, ACVM_WORKING_DIRECTORY } = process.env;
   return {
     acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
@@ -19,10 +19,10 @@ export function getSimulationProviderConfigFromEnv() {
   };
 }
 
-export async function createSimulationProvider(
-  config: SimulationProviderConfig,
+export async function createSimulator(
+  config: SimulatorConfig,
   logger: Logger = createLogger('simulator'),
-): Promise<SimulationProvider> {
+): Promise<CircuitSimulator> {
   if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
     try {
       await fs.access(config.acvmBinaryPath, fs.constants.R_OK);

package/src/public/avm/avm_context.ts

@@ -1,11 +1,11 @@
 import type { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import type { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { type Gas, gasToGasLeft } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
-import type { AvmSimulator } from './avm_simulator.js';
-import type { AvmPersistableStateManager } from './journal/journal.js';
+import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
 
 /**
  * An execution context includes the information necessary to initiate AVM
@@ -20,14 +20,14 @@ export class AvmContext {
    * @returns new AvmContext instance
    */
   constructor(
-    public persistableState: AvmPersistableStateManager,
+    public persistableState: PublicPersistableStateManager,
     public environment: AvmExecutionEnvironment,
     public machineState: AvmMachineState,
   ) {}
 
   // This is needed to break a dependency cycle created by the CALL opcode,
   // which needs to create a new simulator but cannot depend directly on AvmSimulator.
-  public provideSimulator?: (ctx: this) => Promise<AvmSimulator>;
+  public provideSimulator?: (context: AvmContext) => Promise<AvmSimulatorInterface>;
 
   /**
    * Prepare a new AVM context that will be ready for an external/nested call

package/src/public/avm/avm_contract_call_result.ts

@@ -17,19 +17,28 @@ export class AvmContractCallResult {
     public output: Fr[],
     public gasLeft: AvmGas,
     public revertReason?: AvmRevertReason,
+    public totalInstructions: number = 0, // including nested calls
   ) {}
 
   toString(): string {
-    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(
+      this.gasLeft,
+    )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
-      resultsStr += `, revertReason: ${this.revertReason}`;
+      resultsStr += `, revertReason: ${this.revertReason.message}`;
     }
     return resultsStr;
   }
 
   finalize(): AvmFinalizedCallResult {
     const revertReason = this.revertReason ? createSimulationError(this.revertReason, this.output) : undefined;
-    return new AvmFinalizedCallResult(this.reverted, this.output, Gas.from(this.gasLeft), revertReason);
+    return new AvmFinalizedCallResult(
+      this.reverted,
+      this.output,
+      Gas.from(this.gasLeft),
+      revertReason,
+      this.totalInstructions,
+    );
   }
 }
 
@@ -43,12 +52,15 @@ export class AvmFinalizedCallResult {
     public output: Fr[],
     public gasLeft: Gas,
     public revertReason?: SimulationError,
+    public totalInstructions: number = 0, // including nested calls
   ) {}
 
   toString(): string {
-    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(
+      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

@@ -1,3 +1,4 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
@@ -15,9 +16,15 @@ export class AvmExecutionEnvironment {
     public readonly globals: GlobalVariables,
     public readonly isStaticCall: boolean,
     public readonly calldata: Fr[],
+    public readonly clientInitiatedSimulation: boolean = false,
+    public readonly maxDebugLogMemoryReads: number = DEFAULT_MAX_DEBUG_LOG_MEMORY_READS,
   ) {}
 
-  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 +33,8 @@ export class AvmExecutionEnvironment {
       this.globals,
       isStaticCall,
       calldata,
+      this.clientInitiatedSimulation,
+      this.maxDebugLogMemoryReads,
     );
   }
 

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. */
@@ -105,13 +104,13 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.MOV_8]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.MOV_16]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_BASE_L2_GAS, 0),
-  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, c.AVM_SSTORE_BASE_DA_GAS),
+  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, 0), // DA gas is dynamic
   [Opcode.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_BASE_L2_GAS, 0),
   [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_BASE_L2_GAS, c.AVM_EMITNOTEHASH_BASE_DA_GAS),
   [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_BASE_L2_GAS, 0),
   [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_BASE_L2_GAS, c.AVM_EMITNULLIFIER_BASE_DA_GAS),
   [Opcode.L1TOL2MSGEXISTS]: makeCost(c.AVM_L1TOL2MSGEXISTS_BASE_L2_GAS, 0),
-  [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_BASE_L2_GAS, 0),
+  [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_BASE_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_BASE_DA_GAS),
   [Opcode.SENDL2TOL1MSG]: makeCost(c.AVM_SENDL2TOL1MSG_BASE_L2_GAS, c.AVM_SENDL2TOL1MSG_BASE_DA_GAS),
   [Opcode.GETCONTRACTINSTANCE]: makeCost(c.AVM_GETCONTRACTINSTANCE_BASE_L2_GAS, 0),
   [Opcode.CALL]: makeCost(c.AVM_CALL_BASE_L2_GAS, 0),
@@ -130,14 +129,16 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
 const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.CALLDATACOPY, makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0)],
   [Opcode.RETURNDATACOPY, makeCost(c.AVM_RETURNDATACOPY_DYN_L2_GAS, 0)],
+  // TODO: Call and static call based on bytecode length
   [Opcode.EMITUNENCRYPTEDLOG, makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_DYN_DA_GAS)],
-  [Opcode.CALL, makeCost(c.AVM_CALL_DYN_L2_GAS, 0)],
-  [Opcode.STATICCALL, makeCost(c.AVM_STATICCALL_DYN_L2_GAS, 0)],
-  [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)],
+  [Opcode.AND_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.AND_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.OR_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.OR_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.XOR_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.XOR_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.SSTORE, makeCost(0, c.AVM_SSTORE_DYN_DA_GAS)],
 ]);
 
 /** Returns the fixed base gas cost for a given opcode. */
@@ -145,35 +146,22 @@ export function getBaseGasCost(opcode: Opcode): Gas {
   return BASE_GAS_COSTS[opcode];
 }
 
-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 });
+export function computeAddressingCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas {
+  return makeCost(
+    (relativeOperandsCount !== 0 ? c.AVM_ADDRESSING_BASE_RESOLUTION_L2_GAS : 0) +
+      indirectOperandsCount * c.AVM_ADDRESSING_INDIRECT_L2_GAS +
+      relativeOperandsCount * c.AVM_ADDRESSING_RELATIVE_L2_GAS,
+    0,
+  );
 }
 
-/** 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));
+export function getDynamicGasCost(opcode: Opcode): Gas {
+  return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
 }
 
-/** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */
-function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
+/** Returns a multiplier based on the byte size of the type represented by the integer tag.
+ * Used to account for necessary rows in the bitwise trace. Throws on invalid. */
+export function getBitwiseDynamicGasMultiplier(tag: TypeTag) {
   switch (tag) {
     case TypeTag.UINT1: // same as u8
       return 1;
@@ -188,7 +176,7 @@ function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
     case TypeTag.UINT128:
       return 16;
     case TypeTag.FIELD:
-      return 32;
+      return 0; // Field is not allowed for bitwise operations. However we don't fail in gas, since we'll fail in bitwise.
     case TypeTag.INVALID:
       throw new InstructionExecutionError(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
   }

package/src/public/avm/avm_machine_state.ts

@@ -68,6 +68,11 @@ export class AvmMachineState {
   /** Output data must NOT be modified once it is set */
   private output: Fr[] = [];
 
+  // Metrics only - not needed for execution
+  /** instruction counter, including nested calls */
+  public instrCounter: number = 0;
+  // End metrics only
+
   constructor(gasLeft: Gas);
   constructor(l2GasLeft: number, daGasLeft: number);
   constructor(gasLeftOrL2GasLeft: Gas | number, daGasLeft?: number) {

package/src/public/avm/avm_memory_types.ts

@@ -32,6 +32,9 @@ export abstract class MemoryValue {
 
   // Use sparingly.
   public abstract toBigInt(): bigint;
+  public getTag(): TypeTag {
+    return TaggedMemory.getTag(this);
+  }
 
   // To Buffer
   public abstract toBuffer(): Buffer;
@@ -71,6 +74,7 @@ export abstract class IntegralValue extends MemoryValue {
  **/
 function UnsignedIntegerClassFactory(bits: number) {
   return class NewUintClass extends IntegralValue {
+    static readonly bits: number = bits;
     static readonly mod: bigint = 1n << BigInt(bits);
     static readonly bitmask: bigint = this.mod - 1n;
     public readonly n: bigint; // Cannot be private due to TS limitations.
@@ -78,6 +82,7 @@ function UnsignedIntegerClassFactory(bits: number) {
     public constructor(n: bigint | number) {
       super();
       this.n = BigInt(n);
+      assert(n >= 0n, `${this.constructor.name} cannot handle negative values: ${n}.`);
       assert(n < NewUintClass.mod, `Value ${n} is too large for ${this.constructor.name}.`);
     }
 
@@ -104,12 +109,20 @@ function UnsignedIntegerClassFactory(bits: number) {
 
     // No sign extension.
     public shr(rhs: NewUintClass): NewUintClass {
-      // Note that this.n is > 0 by class invariant.
+      // Note that this.n is >= 0 by class invariant.
       return this.build(this.n >> rhs.n);
     }
 
     public shl(rhs: NewUintClass): NewUintClass {
-      return this.build((this.n << rhs.n) & NewUintClass.bitmask);
+      const shiftAmount = rhs.n;
+      const bitSize = BigInt(NewUintClass.bits);
+
+      // Shifting by more than the bit size always results in 0
+      if (shiftAmount >= bitSize) {
+        return this.build(0n);
+      }
+
+      return this.build((this.n << shiftAmount) & NewUintClass.bitmask);
     }
 
     public and(rhs: NewUintClass): NewUintClass {
@@ -252,7 +265,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public getAs<T>(offset: number): T {
     assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem.get(offset);
-    //TaggedMemory.log.trace(`get(${offset}) = ${word}`);
+    //TaggedMemory.log.trace(`Memory read: ${offset} -> ${word}`);
     if (word === undefined) {
       TaggedMemory.log.debug(`WARNING: Memory at offset ${offset} is undefined!`);
       return new Field(0) as T;
@@ -288,7 +301,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public set(offset: number, v: MemoryValue) {
     assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem.set(offset, v);
-    //TaggedMemory.log.trace(`set(${offset}, ${v})`);
+    //TaggedMemory.log.trace(`Memory write: ${offset} <- ${v}`);
   }
 
   public setSlice(offset: number, slice: MemoryValue[]) {
@@ -319,8 +332,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
     }
   }
 
-  public checkIsValidMemoryOffsetTag(offset: number) {
-    this.checkTag(TypeTag.UINT32, offset);
+  public static isValidMemoryAddressTag(tag: TypeTag) {
+    return tag === TypeTag.UINT32;
   }
 
   public static checkIsIntegralTag(tag: TypeTag) {

package/src/public/avm/avm_simulator.ts

@@ -1,27 +1,22 @@
-import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
-import { SideEffectLimitReachedError } from '../side_effect_errors.js';
+import { CheckedPublicExecutionError } from '../public_errors.js';
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
 import { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import type { Gas } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
-import { isAvmBytecode } from './bytecode_utils.js';
-import {
-  AvmExecutionError,
-  AvmRevertReason,
-  InvalidProgramCounterError,
-  revertReasonFromExceptionalHalt,
-  revertReasonFromExplicitRevert,
-} from './errors.js';
-import type { AvmPersistableStateManager } from './journal/journal.js';
+import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
+import { AvmRevertReason, InvalidProgramCounterError } from './errors.js';
 import type { Instruction } from './opcodes/instruction.js';
+import { revertReasonFromExceptionalHalt, revertReasonFromExplicitRevert } from './revert_reason.js';
 import {
   INSTRUCTION_SET,
   type InstructionSet,
@@ -33,7 +28,7 @@ type OpcodeTally = {
   gas: Gas;
 };
 
-export class AvmSimulator {
+export class AvmSimulator implements AvmSimulatorInterface {
   private log: Logger;
   private bytecode: Buffer | undefined;
   private opcodeTallies: Map<string, OpcodeTally> = new Map();
@@ -53,10 +48,6 @@ export class AvmSimulator {
     // This will be used by the CALL opcode to create a new simulator. It is required to
     // avoid a dependency cycle.
     context.provideSimulator = AvmSimulator.build;
-    assert(
-      context.machineState.gasLeft.l2Gas <= MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
-      `Cannot allocate more than ${MAX_L2_GAS_PER_TX_PUBLIC_PORTION} to the AVM for execution.`,
-    );
     this.log = createLogger(`simulator:avm(calldata[0]: ${context.environment.calldata[0]})`);
     // Turn on tallying if explicitly enabled or if trace logging
     if (enableTallying || this.log.isLevelEnabled('trace')) {
@@ -76,7 +67,7 @@ export class AvmSimulator {
   }
 
   public static async create(
-    stateManager: AvmPersistableStateManager,
+    stateManager: PublicPersistableStateManager,
     address: AztecAddress,
     sender: AztecAddress,
     transactionFee: Fr,
@@ -84,6 +75,8 @@ export class AvmSimulator {
     isStaticCall: boolean,
     calldata: Fr[],
     allocatedGas: Gas,
+    clientInitiatedSimulation: boolean = false,
+    maxDebugLogMemoryReads?: number,
   ) {
     const avmExecutionEnv = new AvmExecutionEnvironment(
       address,
@@ -93,6 +86,8 @@ export class AvmSimulator {
       globals,
       isStaticCall,
       calldata,
+      clientInitiatedSimulation,
+      maxDebugLogMemoryReads,
     );
 
     const avmMachineState = new AvmMachineState(allocatedGas);
@@ -104,22 +99,13 @@ export class AvmSimulator {
    * Fetch the bytecode and execute it in the current context.
    */
   public async execute(): Promise<AvmContractCallResult> {
-    let bytecode: Buffer | undefined;
-    try {
-      bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
-    } catch (err: any) {
-      if (!(err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
-        this.log.error(`Unknown error thrown by AVM during bytecode retrieval: ${err}`);
-        throw err;
-      }
-      return await this.handleFailureToRetrieveBytecode(
-        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err}. Reverting...`,
-      );
-    }
+    const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
+    // getBytecode returns undefined if bytecode is not found or if the limit of contract calls to unique class IDs is reached.
+    // If it throws an error that reaches this point, it is a bug.
 
     if (!bytecode) {
       return await this.handleFailureToRetrieveBytecode(
-        `No bytecode found at: ${this.context.environment.address}. Reverting...`,
+        `No bytecode found, or limit encountered for max calls to unique contract class IDs. Contract address: ${this.context.environment.address}. Reverting...`,
       );
     }
 
@@ -138,18 +124,17 @@ export class AvmSimulator {
    * This method is useful for testing and debugging.
    */
   public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
-    const startTotalTime = performance.now();
-    assert(isAvmBytecode(bytecode), "AVM simulator can't execute non-AVM bytecode");
+    const timer = new Timer();
     assert(bytecode.length > 0, "AVM simulator can't execute empty bytecode");
 
     this.bytecode = bytecode;
+    let instructionName = 'NONE'; // This is used for logging purposes
 
     const { machineState } = this.context;
     const callStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
-      let instrCounter = 0;
       while (!machineState.getHalted()) {
         // Get the instruction from cache, or deserialize for the first time
         let cachedInstruction = this.deserializedInstructionsCache.get(machineState.pc);
@@ -165,15 +150,14 @@ export class AvmSimulator {
         if (this.log.isLevelEnabled('trace')) {
           // Skip this entirely to avoid toStringing etc if trace is not enabled
           this.log.trace(
-            `[PC:${machineState.pc}] [IC:${instrCounter}] ${instruction.toString()} (gasLeft l2=${
+            `[PC:${machineState.pc}] [IC:${machineState.instrCounter}] ${instruction.toString()} (gasLeft l2=${
               machineState.l2GasLeft
             } da=${machineState.daGasLeft})`,
           );
         }
-        instrCounter++;
-
         machineState.nextPc = machineState.pc + bytesRead;
 
+        instructionName = instruction.constructor.name;
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
@@ -183,6 +167,8 @@ export class AvmSimulator {
           machineState.pc += bytesRead;
         }
 
+        machineState.instrCounter++;
+
         // gas used by this instruction - used for profiling/tallying
         const gasUsed: Gas = {
           l2Gas: instrStartGas.l2Gas - machineState.l2GasLeft,
@@ -199,35 +185,33 @@ export class AvmSimulator {
       const output = machineState.getOutput();
       const reverted = machineState.getReverted();
       const revertReason = reverted ? await revertReasonFromExplicitRevert(output, this.context) : undefined;
-      const results = new AvmContractCallResult(reverted, output, machineState.gasLeft, revertReason);
+      const results = new AvmContractCallResult(
+        reverted,
+        output,
+        machineState.gasLeft,
+        revertReason,
+        machineState.instrCounter,
+      );
       this.log.debug(`Context execution results: ${results.toString()}`);
       const totalGasUsed: Gas = {
         l2Gas: callStartGas.l2Gas - machineState.l2GasLeft,
         daGas: callStartGas.daGas - machineState.daGasLeft,
       };
-      this.log.debug(`Executed ${instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
+      this.log.debug(`Executed ${machineState.instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
 
       this.tallyPrintFunction();
 
-      const endTotalTime = performance.now();
-      const totalTime = endTotalTime - startTotalTime;
-      this.log.debug(`Core AVM simulation took ${totalTime}ms`);
+      this.log.debug(`Core AVM simulation took ${timer.ms()}ms`);
 
       // Return results for processing by calling context
       return results;
     } catch (err: any) {
-      this.log.verbose('Exceptional halt (revert by something other than REVERT opcode)');
-      // FIXME: weird that we have to do this OutOfGasError check because:
-      // 1. OutOfGasError is an AvmExecutionError, so that check should cover both
-      // 2. We should at least be able to do instanceof OutOfGasError instead of checking the constructor name
-      if (
-        !(
-          err.constructor.name == 'OutOfGasError' ||
-          err instanceof AvmExecutionError ||
-          err instanceof SideEffectLimitReachedError
-        )
-      ) {
-        this.log.error(`Unknown error thrown by AVM: ${err}`);
+      this.log.info(
+        `Exceptional halt (revert by something other than REVERT opcode) for instruction
+         ${instructionName} at pc ${machineState.pc} and instruction counter ${machineState.instrCounter}`,
+      );
+      if (!(err instanceof CheckedPublicExecutionError)) {
+        this.log.error(`Unchecked/unknown error thrown by AVM. This is a bug. Error: ${err}`);
         throw err;
       }
 
@@ -235,7 +219,13 @@ export class AvmSimulator {
       // Exceptional halts consume all allocated gas
       const noGasLeft = { l2Gas: 0, daGas: 0 };
       // Note: "exceptional halts" cannot return data, hence [].
-      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], noGasLeft, revertReason);
+      const results = new AvmContractCallResult(
+        /*reverted=*/ true,
+        /*output=*/ [],
+        noGasLeft,
+        revertReason,
+        machineState.instrCounter,
+      );
       this.log.debug(`Context execution results: ${results.toString()}`);
 
       this.tallyPrintFunction();

package/src/public/avm/avm_simulator_interface.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface for AvmSimulator to break the circular dependency between avm_context.ts and avm_simulator.ts
+ */
+export interface AvmSimulatorInterface {
+  execute(): Promise<any>; // Using any here to avoid importing AvmContractCallResult
+  executeBytecode(bytecode: Buffer): Promise<any>;
+  getBytecode(): Buffer | undefined;
+}