@aztec/simulator 0.74.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/acvm/oracle/typed_oracle.ts

@@ -57,70 +57,70 @@ export abstract class TypedOracle {
   }
 
   storeInExecutionCache(_values: Fr[]): Promise<Fr> {
-    throw new OracleMethodNotAvailableError('storeInExecutionCache');
+    return Promise.reject(new OracleMethodNotAvailableError('storeInExecutionCache'));
   }
 
   loadFromExecutionCache(_hash: Fr): Promise<Fr[]> {
-    throw new OracleMethodNotAvailableError('loadFromExecutionCache');
+    return Promise.reject(new OracleMethodNotAvailableError('loadFromExecutionCache'));
   }
 
   getBlockNumber(): Promise<number> {
-    throw new OracleMethodNotAvailableError('getBlockNumber');
+    return Promise.reject(new OracleMethodNotAvailableError('getBlockNumber'));
   }
 
   getContractAddress(): Promise<AztecAddress> {
-    throw new OracleMethodNotAvailableError('getContractAddress');
+    return Promise.reject(new OracleMethodNotAvailableError('getContractAddress'));
   }
 
   getChainId(): Promise<Fr> {
-    throw new OracleMethodNotAvailableError('getChainId');
+    return Promise.reject(new OracleMethodNotAvailableError('getChainId'));
   }
 
   getVersion(): Promise<Fr> {
-    throw new OracleMethodNotAvailableError('getVersion');
+    return Promise.reject(new OracleMethodNotAvailableError('getVersion'));
   }
 
   getKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest> {
-    throw new OracleMethodNotAvailableError('getKeyValidationRequest');
+    return Promise.reject(new OracleMethodNotAvailableError('getKeyValidationRequest'));
   }
 
   getContractInstance(_address: AztecAddress): Promise<ContractInstance> {
-    throw new OracleMethodNotAvailableError('getContractInstance');
+    return Promise.reject(new OracleMethodNotAvailableError('getContractInstance'));
   }
 
   getMembershipWitness(_blockNumber: number, _treeId: MerkleTreeId, _leafValue: Fr): Promise<Fr[] | undefined> {
-    throw new OracleMethodNotAvailableError('getMembershipWitness');
+    return Promise.reject(new OracleMethodNotAvailableError('getMembershipWitness'));
   }
 
   getNullifierMembershipWitness(_blockNumber: number, _nullifier: Fr): Promise<NullifierMembershipWitness | undefined> {
-    throw new OracleMethodNotAvailableError('getNullifierMembershipWitness');
+    return Promise.reject(new OracleMethodNotAvailableError('getNullifierMembershipWitness'));
   }
 
   getPublicDataTreeWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    throw new OracleMethodNotAvailableError('getPublicDataTreeWitness');
+    return Promise.reject(new OracleMethodNotAvailableError('getPublicDataTreeWitness'));
   }
 
   getLowNullifierMembershipWitness(
     _blockNumber: number,
     _nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    throw new OracleMethodNotAvailableError('getLowNullifierMembershipWitness');
+    return Promise.reject(new OracleMethodNotAvailableError('getLowNullifierMembershipWitness'));
   }
 
   getBlockHeader(_blockNumber: number): Promise<BlockHeader | undefined> {
-    throw new OracleMethodNotAvailableError('getBlockHeader');
+    return Promise.reject(new OracleMethodNotAvailableError('getBlockHeader'));
   }
 
   getCompleteAddress(_account: AztecAddress): Promise<CompleteAddress> {
-    throw new OracleMethodNotAvailableError('getCompleteAddress');
+    return Promise.reject(new OracleMethodNotAvailableError('getCompleteAddress'));
   }
 
   getAuthWitness(_messageHash: Fr): Promise<Fr[] | undefined> {
-    throw new OracleMethodNotAvailableError('getAuthWitness');
+    return Promise.reject(new OracleMethodNotAvailableError('getAuthWitness'));
   }
 
   popCapsule(): Promise<Fr[]> {
-    throw new OracleMethodNotAvailableError('popCapsule');
+    return Promise.reject(new OracleMethodNotAvailableError('popCapsule'));
   }
 
   getNotes(
@@ -139,7 +139,7 @@ export abstract class TypedOracle {
     _offset: number,
     _status: NoteStatus,
   ): Promise<NoteData[]> {
-    throw new OracleMethodNotAvailableError('getNotes');
+    return Promise.reject(new OracleMethodNotAvailableError('getNotes'));
   }
 
   notifyCreatedNote(_storageSlot: Fr, _noteTypeId: NoteSelector, _note: Fr[], _noteHash: Fr, _counter: number): void {
@@ -147,15 +147,15 @@ export abstract class TypedOracle {
   }
 
   notifyNullifiedNote(_innerNullifier: Fr, _noteHash: Fr, _counter: number): Promise<void> {
-    throw new OracleMethodNotAvailableError('notifyNullifiedNote');
+    return Promise.reject(new OracleMethodNotAvailableError('notifyNullifiedNote'));
   }
 
   notifyCreatedNullifier(_innerNullifier: Fr): Promise<void> {
-    throw new OracleMethodNotAvailableError('notifyCreatedNullifier');
+    return Promise.reject(new OracleMethodNotAvailableError('notifyCreatedNullifier'));
   }
 
   checkNullifierExists(_innerNullifier: Fr): Promise<boolean> {
-    throw new OracleMethodNotAvailableError('checkNullifierExists');
+    return Promise.reject(new OracleMethodNotAvailableError('checkNullifierExists'));
   }
 
   getL1ToL2MembershipWitness(
@@ -163,7 +163,7 @@ export abstract class TypedOracle {
     _messageHash: Fr,
     _secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    throw new OracleMethodNotAvailableError('getL1ToL2MembershipWitness');
+    return Promise.reject(new OracleMethodNotAvailableError('getL1ToL2MembershipWitness'));
   }
 
   storageRead(
@@ -172,11 +172,11 @@ export abstract class TypedOracle {
     _blockNumber: number,
     _numberOfElements: number,
   ): Promise<Fr[]> {
-    throw new OracleMethodNotAvailableError('storageRead');
+    return Promise.reject(new OracleMethodNotAvailableError('storageRead'));
   }
 
   storageWrite(_startStorageSlot: Fr, _values: Fr[]): Promise<Fr[]> {
-    throw new OracleMethodNotAvailableError('storageWrite');
+    return Promise.reject(new OracleMethodNotAvailableError('storageWrite'));
   }
 
   emitContractClassLog(_log: UnencryptedL2Log, _counter: number): Fr {
@@ -190,7 +190,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
   ): Promise<{ endSideEffectCounter: Fr; returnsHash: Fr }> {
-    throw new OracleMethodNotAvailableError('callPrivateFunction');
+    return Promise.reject(new OracleMethodNotAvailableError('callPrivateFunction'));
   }
 
   enqueuePublicFunctionCall(
@@ -200,7 +200,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
   ): Promise<Fr> {
-    throw new OracleMethodNotAvailableError('enqueuePublicFunctionCall');
+    return Promise.reject(new OracleMethodNotAvailableError('enqueuePublicFunctionCall'));
   }
 
   setPublicTeardownFunctionCall(
@@ -210,7 +210,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
   ): Promise<Fr> {
-    throw new OracleMethodNotAvailableError('setPublicTeardownFunctionCall');
+    return Promise.reject(new OracleMethodNotAvailableError('setPublicTeardownFunctionCall'));
   }
 
   notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): void {
@@ -222,15 +222,15 @@ export abstract class TypedOracle {
   }
 
   getIndexedTaggingSecretAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<IndexedTaggingSecret> {
-    throw new OracleMethodNotAvailableError('getIndexedTaggingSecretAsSender');
+    return Promise.reject(new OracleMethodNotAvailableError('getIndexedTaggingSecretAsSender'));
   }
 
   incrementAppTaggingSecretIndexAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<void> {
-    throw new OracleMethodNotAvailableError('incrementAppTaggingSecretIndexAsSender');
+    return Promise.reject(new OracleMethodNotAvailableError('incrementAppTaggingSecretIndexAsSender'));
   }
 
   syncNotes(): Promise<void> {
-    throw new OracleMethodNotAvailableError('syncNotes');
+    return Promise.reject(new OracleMethodNotAvailableError('syncNotes'));
   }
 
   deliverNote(
@@ -243,22 +243,22 @@ export abstract class TypedOracle {
     _txHash: Fr,
     _recipient: AztecAddress,
   ): Promise<void> {
-    throw new OracleMethodNotAvailableError('deliverNote');
+    return Promise.reject(new OracleMethodNotAvailableError('deliverNote'));
   }
 
   dbStore(_contractAddress: AztecAddress, _key: Fr, _values: Fr[]): Promise<void> {
-    throw new OracleMethodNotAvailableError('dbStore');
+    return Promise.reject(new OracleMethodNotAvailableError('dbStore'));
   }
 
   dbLoad(_contractAddress: AztecAddress, _key: Fr): Promise<Fr[] | null> {
-    throw new OracleMethodNotAvailableError('dbLoad');
+    return Promise.reject(new OracleMethodNotAvailableError('dbLoad'));
   }
 
   dbDelete(_contractAddress: AztecAddress, _key: Fr): Promise<void> {
-    throw new OracleMethodNotAvailableError('dbDelete');
+    return Promise.reject(new OracleMethodNotAvailableError('dbDelete'));
   }
 
   dbCopy(_contractAddress: AztecAddress, _srcKey: Fr, _dstKey: Fr, _numEntries: number): Promise<void> {
-    throw new OracleMethodNotAvailableError('dbCopy');
+    return Promise.reject(new OracleMethodNotAvailableError('dbCopy'));
   }
 }

package/src/avm/avm_machine_state.ts

@@ -1,6 +1,6 @@
 import { type Fr } from '@aztec/circuits.js';
 
-import { GAS_DIMENSIONS, type Gas } from './avm_gas.js';
+import { type Gas } from './avm_gas.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { type AvmRevertReason, OutOfGasError } from './errors.js';
 
@@ -92,26 +92,29 @@ export class AvmMachineState {
    */
   public consumeGas(gasCost: Partial<Gas>) {
     // Assert there is enough gas on every dimension.
-    const outOfGasDimensions = GAS_DIMENSIONS.filter(
-      dimension => this[`${dimension}Left`] - (gasCost[dimension] ?? 0) < 0,
-    );
+    const outOfL2Gas = this.l2GasLeft - (gasCost.l2Gas ?? 0) < 0;
+    const outOfDaGas = this.daGasLeft - (gasCost.daGas ?? 0) < 0;
     // If not, trigger an exceptional halt.
-    // See https://yp-aztec.netlify.app/docs/public-vm/execution#gas-checks-and-tracking
-    if (outOfGasDimensions.length > 0) {
+    if (outOfL2Gas || outOfDaGas) {
       this.exceptionalHalt();
-      throw new OutOfGasError(outOfGasDimensions);
+      const dimensions = [];
+      if (outOfL2Gas) {
+        dimensions.push('l2Gas');
+      }
+      if (outOfDaGas) {
+        dimensions.push('daGas');
+      }
+      throw new OutOfGasError(dimensions);
     }
     // Otherwise, charge the corresponding gas
-    for (const dimension of GAS_DIMENSIONS) {
-      this[`${dimension}Left`] -= gasCost[dimension] ?? 0;
-    }
+    this.l2GasLeft -= gasCost.l2Gas ?? 0;
+    this.daGasLeft -= gasCost.daGas ?? 0;
   }
 
   /** Increases the gas left by the amounts specified. */
   public refundGas(gasRefund: Partial<Gas>) {
-    for (const dimension of GAS_DIMENSIONS) {
-      this[`${dimension}Left`] += gasRefund[dimension] ?? 0;
-    }
+    this.l2GasLeft += gasRefund.l2Gas ?? 0;
+    this.daGasLeft += gasRefund.daGas ?? 0;
   }
 
   /**
@@ -151,7 +154,8 @@ export class AvmMachineState {
    * Flag an exceptional halt. Clears gas left and sets the reverted flag. No output data.
    */
   private exceptionalHalt() {
-    GAS_DIMENSIONS.forEach(dimension => (this[`${dimension}Left`] = 0));
+    this.l2GasLeft = 0;
+    this.daGasLeft = 0;
     this.reverted = true;
     this.halted = true;
   }

package/src/avm/avm_memory_types.ts

@@ -15,13 +15,7 @@ import { type FunctionsOf } from '@aztec/foundation/types';
 
 import { strict as assert } from 'assert';
 
-import {
-  InstructionExecutionError,
-  InvalidTagValueError,
-  MemorySliceOutOfRangeError,
-  TagCheckError,
-} from './errors.js';
-import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
+import { InvalidTagValueError, MemorySliceOutOfRangeError, TagCheckError } from './errors.js';
 
 /** MemoryValue gathers the common operations for all memory types. */
 export abstract class MemoryValue {
@@ -251,22 +245,14 @@ export class TaggedMemory implements TaggedMemoryInterface {
     return TaggedMemory.MAX_MEMORY_SIZE;
   }
 
-  /** Returns a MeteredTaggedMemory instance to track the number of reads and writes if TRACK_MEMORY_ACCESSES is set. */
-  public track(type: string = 'instruction'): TaggedMemoryInterface {
-    return TaggedMemory.TRACK_MEMORY_ACCESSES ? new MeteredTaggedMemory(this, type) : this;
-  }
-
   public get(offset: number): MemoryValue {
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    const value = this.getAs<MemoryValue>(offset);
-    return value;
+    return this.getAs<MemoryValue>(offset);
   }
 
   public getAs<T>(offset: number): T {
-    assert(Number.isInteger(offset));
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
+    assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem.get(offset);
-    TaggedMemory.log.trace(`get(${offset}) = ${word}`);
+    //TaggedMemory.log.trace(`get(${offset}) = ${word}`);
     if (word === undefined) {
       TaggedMemory.log.debug(`WARNING: Memory at offset ${offset} is undefined!`);
       return new Field(0) as T;
@@ -300,10 +286,9 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public set(offset: number, v: MemoryValue) {
-    assert(Number.isInteger(offset));
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
+    assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem.set(offset, v);
-    TaggedMemory.log.trace(`set(${offset}, ${v})`);
+    //TaggedMemory.log.trace(`set(${offset}, ${v})`);
   }
 
   public setSlice(offset: number, slice: MemoryValue[]) {
@@ -320,8 +305,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public getTag(offset: number): TypeTag {
-    assert(Number.isInteger(offset));
-    assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
+    assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
     return TaggedMemory.getTag(this._mem.get(offset));
   }
 
@@ -340,25 +324,13 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public static checkIsIntegralTag(tag: TypeTag) {
-    if (
-      ![TypeTag.UINT1, TypeTag.UINT8, TypeTag.UINT16, TypeTag.UINT32, TypeTag.UINT64, TypeTag.UINT128].includes(tag)
-    ) {
+    if (!INTEGRAL_TAGS.has(tag)) {
       throw TagCheckError.forTag(TypeTag[tag], 'integral');
     }
   }
 
   public static checkIsValidTag(tagNumber: number) {
-    if (
-      ![
-        TypeTag.FIELD,
-        TypeTag.UINT1,
-        TypeTag.UINT8,
-        TypeTag.UINT16,
-        TypeTag.UINT32,
-        TypeTag.UINT64,
-        TypeTag.UINT128,
-      ].includes(tagNumber)
-    ) {
+    if (!VALID_TAGS.has(tagNumber)) {
       throw new InvalidTagValueError(tagNumber);
     }
   }
@@ -375,11 +347,9 @@ export class TaggedMemory implements TaggedMemoryInterface {
   /**
    * Check that all tags at the given offsets are the same.
    */
-  public checkTagsAreSame(...offsets: number[]) {
-    const tag = this.getTag(offsets[0]);
-    for (let i = 1; i < offsets.length; i++) {
-      this.checkTag(tag, offsets[i]);
-    }
+  public checkTagsAreSame(offset0: number, offset1: number) {
+    const tag0 = this.getTag(offset0);
+    this.checkTag(tag0, offset1);
   }
 
   /**
@@ -391,32 +361,12 @@ export class TaggedMemory implements TaggedMemoryInterface {
     }
   }
 
-  // TODO: this might be slow, but I don't want to have the types know of their tags.
-  // It might be possible to have a map<Prototype, TypeTag>.
   public static getTag(v: MemoryValue | undefined): TypeTag {
-    let tag = TypeTag.INVALID;
-
-    // Not sure why, but using instanceof here doesn't work and leads odd behavior,
-    // but using constructor.name does the job...
     if (v === undefined) {
-      tag = TypeTag.FIELD; // uninitialized memory is Field(0)
-    } else if (v.constructor.name == 'Field') {
-      tag = TypeTag.FIELD;
-    } else if (v.constructor.name == 'Uint1') {
-      tag = TypeTag.UINT1;
-    } else if (v.constructor.name == 'Uint8') {
-      tag = TypeTag.UINT8;
-    } else if (v.constructor.name == 'Uint16') {
-      tag = TypeTag.UINT16;
-    } else if (v.constructor.name == 'Uint32') {
-      tag = TypeTag.UINT32;
-    } else if (v.constructor.name == 'Uint64') {
-      tag = TypeTag.UINT64;
-    } else if (v.constructor.name == 'Uint128') {
-      tag = TypeTag.UINT128;
+      return TypeTag.FIELD; // uninitialized memory is Field(0)
+    } else {
+      return TAG_FOR_MEM_VAL.get(v.constructor.name) ?? TypeTag.INVALID;
     }
-
-    return tag;
   }
 
   // Truncates the value to fit the type.
@@ -441,123 +391,33 @@ export class TaggedMemory implements TaggedMemoryInterface {
         throw new InvalidTagValueError(tag);
     }
   }
-
-  /** No-op. Implemented here for compatibility with the MeteredTaggedMemory. */
-  public assert(_operations: Partial<MemoryOperations & { addressing: Addressing }>) {}
-}
-
-/** Tagged memory wrapper with metering for each memory read and write operation. */
-export class MeteredTaggedMemory implements TaggedMemoryInterface {
-  private reads: number = 0;
-  private writes: number = 0;
-
-  constructor(private wrapped: TaggedMemory, private type: string = 'instruction') {}
-
-  /** Returns the number of reads and writes tracked so far and resets them to zero. */
-  public reset(): MemoryOperations {
-    const stats = { reads: this.reads, writes: this.writes };
-    this.reads = 0;
-    this.writes = 0;
-    return stats;
-  }
-
-  /**
-   * Asserts that the exact number of memory operations have been performed.
-   * Indirect represents the flags for indirect accesses: each bit set to one counts as an extra read.
-   */
-  public assert(operations: Partial<MemoryOperations & { addressing: Addressing }>) {
-    const {
-      reads: expectedReads,
-      writes: expectedWrites,
-      addressing,
-    } = { reads: 0, writes: 0, addressing: new Addressing([]), ...operations };
-
-    const totalExpectedReads =
-      expectedReads + addressing.count(AddressingMode.INDIRECT) + addressing.count(AddressingMode.RELATIVE);
-    const { reads: actualReads, writes: actualWrites } = this.reset();
-    if (actualReads !== totalExpectedReads) {
-      throw new InstructionExecutionError(
-        `Incorrect number of memory reads for ${this.type}: expected ${totalExpectedReads} but executed ${actualReads}`,
-      );
-    }
-    if (actualWrites !== expectedWrites) {
-      throw new InstructionExecutionError(
-        `Incorrect number of memory writes for ${this.type}: expected ${expectedWrites} but executed ${actualWrites}`,
-      );
-    }
-  }
-
-  public getMaxMemorySize(): number {
-    return this.wrapped.getMaxMemorySize();
-  }
-
-  public track(type: string = 'instruction'): MeteredTaggedMemory {
-    return new MeteredTaggedMemory(this.wrapped, type);
-  }
-
-  public get(offset: number): MemoryValue {
-    this.reads++;
-    return this.wrapped.get(offset);
-  }
-
-  public getSliceAs<T>(offset: number, size: number): T[] {
-    this.reads += size;
-    return this.wrapped.getSliceAs<T>(offset, size);
-  }
-
-  public getAs<T>(offset: number): T {
-    this.reads++;
-    return this.wrapped.getAs(offset);
-  }
-
-  public getSlice(offset: number, size: number): MemoryValue[] {
-    this.reads += size;
-    return this.wrapped.getSlice(offset, size);
-  }
-
-  public set(offset: number, v: MemoryValue): void {
-    this.writes++;
-    this.wrapped.set(offset, v);
-  }
-
-  public setSlice(offset: number, vs: MemoryValue[]): void {
-    this.writes += vs.length;
-    this.wrapped.setSlice(offset, vs);
-  }
-
-  public getSliceTags(offset: number, size: number): TypeTag[] {
-    return this.wrapped.getSliceTags(offset, size);
-  }
-
-  public getTag(offset: number): TypeTag {
-    return this.wrapped.getTag(offset);
-  }
-
-  public checkTag(tag: TypeTag, offset: number): void {
-    this.wrapped.checkTag(tag, offset);
-  }
-
-  public checkIsValidMemoryOffsetTag(offset: number): void {
-    this.wrapped.checkIsValidMemoryOffsetTag(offset);
-  }
-
-  public checkTags(tag: TypeTag, ...offsets: number[]): void {
-    this.wrapped.checkTags(tag, ...offsets);
-  }
-
-  public checkTagsAreSame(...offsets: number[]): void {
-    this.wrapped.checkTagsAreSame(...offsets);
-  }
-
-  public checkTagsRange(tag: TypeTag, startOffset: number, size: number): void {
-    this.wrapped.checkTagsRange(tag, startOffset, size);
-  }
 }
 
-/** Tracks number of memory reads and writes. */
-export type MemoryOperations = {
-  /** How many total reads are performed. Slice reads are count as one per element. */
-  reads: number;
-  /** How many total writes are performed. Slice writes are count as one per element. */
-  writes: number;
-};
+const TAG_FOR_MEM_VAL = new Map<string, TypeTag>([
+  ['Field', TypeTag.FIELD],
+  ['Uint1', TypeTag.UINT1],
+  ['Uint8', TypeTag.UINT8],
+  ['Uint16', TypeTag.UINT16],
+  ['Uint32', TypeTag.UINT32],
+  ['Uint64', TypeTag.UINT64],
+  ['Uint128', TypeTag.UINT128],
+]);
+
+const VALID_TAGS = new Set([
+  TypeTag.FIELD,
+  TypeTag.UINT1,
+  TypeTag.UINT8,
+  TypeTag.UINT16,
+  TypeTag.UINT32,
+  TypeTag.UINT64,
+  TypeTag.UINT128,
+]);
+
+const INTEGRAL_TAGS = new Set([
+  TypeTag.UINT1,
+  TypeTag.UINT8,
+  TypeTag.UINT16,
+  TypeTag.UINT32,
+  TypeTag.UINT64,
+  TypeTag.UINT128,
+]);

package/src/avm/avm_simulator.ts

@@ -18,6 +18,7 @@ import {
   revertReasonFromExplicitRevert,
 } from './errors.js';
 import { type AvmPersistableStateManager } from './journal/journal.js';
+import { type Instruction } from './opcodes/instruction.js';
 import {
   INSTRUCTION_SET,
   type InstructionSet,
@@ -33,20 +34,26 @@ export class AvmSimulator {
   private log: Logger;
   private bytecode: Buffer | undefined;
   private opcodeTallies: Map<string, OpcodeTally> = new Map();
+  // maps pc to [instr, bytesRead]
+  private deserializedInstructionsCache: Map<number, [Instruction, number]> = new Map();
 
   private tallyPrintFunction = () => {};
   private tallyInstructionFunction = (_b: string, _c: Gas) => {};
 
   // Test Purposes only: Logger will not have the proper function name. Use this constructor for testing purposes
   // only. Otherwise, use build() below.
-  constructor(private context: AvmContext, private instructionSet: InstructionSet = INSTRUCTION_SET()) {
+  constructor(
+    private context: AvmContext,
+    private instructionSet: InstructionSet = INSTRUCTION_SET(),
+    enableTallying = false,
+  ) {
     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]})`);
-    // TODO(palla/log): Should tallies be printed on debug, or only on trace?
-    if (this.log.isLevelEnabled('debug')) {
+    // Turn on tallying if explicitly enabled or if trace logging
+    if (enableTallying || this.log.isLevelEnabled('trace')) {
       this.tallyPrintFunction = this.printOpcodeTallies;
       this.tallyInstructionFunction = this.tallyInstruction;
     }
@@ -125,6 +132,7 @@ 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");
     assert(bytecode.length > 0, "AVM simulator can't execute empty bytecode");
 
@@ -137,19 +145,32 @@ export class AvmSimulator {
       // continuing until the machine state signifies a halt
       let instrCounter = 0;
       while (!machineState.getHalted()) {
-        const [instruction, bytesRead] = decodeInstructionFromBytecode(bytecode, machineState.pc, this.instructionSet);
+        // Get the instruction from cache, or deserialize for the first time
+        let cachedInstruction = this.deserializedInstructionsCache.get(machineState.pc);
+
+        if (cachedInstruction === undefined) {
+          cachedInstruction = decodeInstructionFromBytecode(bytecode, machineState.pc, this.instructionSet);
+          this.deserializedInstructionsCache.set(machineState.pc, cachedInstruction);
+        }
+        const [instruction, bytesRead] = cachedInstruction;
+
         const instrStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
 
-        this.log.trace(
-          `[PC:${machineState.pc}] [IC:${instrCounter++}] ${instruction.toString()} (gasLeft l2=${
-            machineState.l2GasLeft
-          } da=${machineState.daGasLeft})`,
-        );
+        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=${
+              machineState.l2GasLeft
+            } da=${machineState.daGasLeft})`,
+          );
+        }
+        instrCounter++;
+
+        machineState.nextPc = machineState.pc + bytesRead;
+
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
-        machineState.nextPc = machineState.pc + bytesRead;
-
         await instruction.execute(this.context);
         if (!instruction.handlesPC()) {
           // Increment PC if the instruction doesn't handle it itself
@@ -181,6 +202,11 @@ export class AvmSimulator {
       this.log.debug(`Executed ${instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
 
       this.tallyPrintFunction();
+
+      const endTotalTime = performance.now();
+      const totalTime = endTotalTime - startTotalTime;
+      this.log.debug(`Total execution time: ${totalTime}ms`);
+
       // Return results for processing by calling context
       return results;
     } catch (err: any) {