@aztec/simulator 0.30.1 → 0.32.0

package/src/avm/avm_gas_cost.ts

@@ -0,0 +1,132 @@
+import { TypeTag } from './avm_memory_types.js';
+import { Opcode } from './serialization/instruction_serialization.js';
+
+/** Gas cost in L1, L2, and DA for a given instruction. */
+export type GasCost = {
+  l1Gas: number;
+  l2Gas: number;
+  daGas: number;
+};
+
+/** Creates a new instance with all values set to zero except the ones set. */
+export function makeGasCost(gasCost: Partial<GasCost>) {
+  return { ...EmptyGasCost, ...gasCost };
+}
+
+/** Gas cost of zero across all gas dimensions. */
+export const EmptyGasCost = {
+  l1Gas: 0,
+  l2Gas: 0,
+  daGas: 0,
+};
+
+/** Dimensions of gas usage: L1, L2, and DA. */
+export const GasDimensions = ['l1Gas', 'l2Gas', 'daGas'] as const;
+
+/** Null object to represent a gas cost that's dynamic instead of fixed for a given instruction. */
+export const DynamicGasCost = Symbol('DynamicGasCost');
+
+/** Temporary default gas cost. We should eventually remove all usage of this variable in favor of actual gas for each opcode. */
+const TemporaryDefaultGasCost = { l1Gas: 0, l2Gas: 10, daGas: 0 };
+
+/** Gas costs for each instruction. */
+export const GasCosts = {
+  [Opcode.ADD]: DynamicGasCost,
+  [Opcode.SUB]: DynamicGasCost,
+  [Opcode.MUL]: DynamicGasCost,
+  [Opcode.DIV]: DynamicGasCost,
+  [Opcode.FDIV]: TemporaryDefaultGasCost,
+  [Opcode.EQ]: TemporaryDefaultGasCost,
+  [Opcode.LT]: TemporaryDefaultGasCost,
+  [Opcode.LTE]: TemporaryDefaultGasCost,
+  [Opcode.AND]: TemporaryDefaultGasCost,
+  [Opcode.OR]: TemporaryDefaultGasCost,
+  [Opcode.XOR]: TemporaryDefaultGasCost,
+  [Opcode.NOT]: TemporaryDefaultGasCost,
+  [Opcode.SHL]: TemporaryDefaultGasCost,
+  [Opcode.SHR]: TemporaryDefaultGasCost,
+  [Opcode.CAST]: TemporaryDefaultGasCost,
+  // Execution environment
+  [Opcode.ADDRESS]: TemporaryDefaultGasCost,
+  [Opcode.STORAGEADDRESS]: TemporaryDefaultGasCost,
+  [Opcode.ORIGIN]: TemporaryDefaultGasCost,
+  [Opcode.SENDER]: TemporaryDefaultGasCost,
+  [Opcode.PORTAL]: TemporaryDefaultGasCost,
+  [Opcode.FEEPERL1GAS]: TemporaryDefaultGasCost,
+  [Opcode.FEEPERL2GAS]: TemporaryDefaultGasCost,
+  [Opcode.FEEPERDAGAS]: TemporaryDefaultGasCost,
+  [Opcode.CONTRACTCALLDEPTH]: TemporaryDefaultGasCost,
+  [Opcode.CHAINID]: TemporaryDefaultGasCost,
+  [Opcode.VERSION]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKNUMBER]: TemporaryDefaultGasCost,
+  [Opcode.TIMESTAMP]: TemporaryDefaultGasCost,
+  [Opcode.COINBASE]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKL1GASLIMIT]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKL2GASLIMIT]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKDAGASLIMIT]: TemporaryDefaultGasCost,
+  [Opcode.CALLDATACOPY]: DynamicGasCost,
+  // Gas
+  [Opcode.L1GASLEFT]: TemporaryDefaultGasCost,
+  [Opcode.L2GASLEFT]: TemporaryDefaultGasCost,
+  [Opcode.DAGASLEFT]: TemporaryDefaultGasCost,
+  // Control flow
+  [Opcode.JUMP]: TemporaryDefaultGasCost,
+  [Opcode.JUMPI]: TemporaryDefaultGasCost,
+  [Opcode.INTERNALCALL]: TemporaryDefaultGasCost,
+  [Opcode.INTERNALRETURN]: TemporaryDefaultGasCost,
+  // Memory
+  [Opcode.SET]: DynamicGasCost,
+  [Opcode.MOV]: TemporaryDefaultGasCost,
+  [Opcode.CMOV]: TemporaryDefaultGasCost,
+  // World state
+  [Opcode.SLOAD]: TemporaryDefaultGasCost,
+  [Opcode.SSTORE]: TemporaryDefaultGasCost,
+  [Opcode.NOTEHASHEXISTS]: TemporaryDefaultGasCost,
+  [Opcode.EMITNOTEHASH]: TemporaryDefaultGasCost,
+  [Opcode.NULLIFIEREXISTS]: TemporaryDefaultGasCost,
+  [Opcode.EMITNULLIFIER]: TemporaryDefaultGasCost,
+  [Opcode.L1TOL2MSGEXISTS]: TemporaryDefaultGasCost,
+  [Opcode.HEADERMEMBER]: TemporaryDefaultGasCost,
+  [Opcode.EMITUNENCRYPTEDLOG]: TemporaryDefaultGasCost,
+  [Opcode.SENDL2TOL1MSG]: TemporaryDefaultGasCost,
+  // External calls
+  [Opcode.CALL]: TemporaryDefaultGasCost,
+  [Opcode.STATICCALL]: TemporaryDefaultGasCost,
+  [Opcode.DELEGATECALL]: TemporaryDefaultGasCost,
+  [Opcode.RETURN]: TemporaryDefaultGasCost,
+  [Opcode.REVERT]: TemporaryDefaultGasCost,
+  // Gadgets
+  [Opcode.KECCAK]: TemporaryDefaultGasCost,
+  [Opcode.POSEIDON]: TemporaryDefaultGasCost,
+  [Opcode.SHA256]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,
+  [Opcode.PEDERSEN]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,t
+} as const;
+
+/** Constants used in base cost calculations. */
+export const GasCostConstants = {
+  SET_COST_PER_BYTE: 100,
+  CALLDATACOPY_COST_PER_BYTE: 10,
+  ARITHMETIC_COST_PER_BYTE: 10,
+  ARITHMETIC_COST_PER_INDIRECT_ACCESS: 5,
+};
+
+/** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */
+export function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
+  switch (tag) {
+    case TypeTag.UINT8:
+      return 1;
+    case TypeTag.UINT16:
+      return 2;
+    case TypeTag.UINT32:
+      return 4;
+    case TypeTag.UINT64:
+      return 8;
+    case TypeTag.UINT128:
+      return 16;
+    case TypeTag.FIELD:
+      return 32;
+    case TypeTag.INVALID:
+    case TypeTag.UNINITIALIZED:
+      throw new Error(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
+  }
+}

package/src/avm/avm_machine_state.ts

@@ -1,7 +1,9 @@
 import { Fr } from '@aztec/circuits.js';
 
+import { GasCost, GasDimensions } from './avm_gas_cost.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { AvmContractCallResults } from './avm_message_call_result.js';
+import { OutOfGasError } from './errors.js';
 
 /**
  * A few fields of machine state are initialized from AVM session inputs or call instruction arguments
@@ -35,7 +37,7 @@ export class AvmMachineState {
   /**
    * Signals that execution should end.
    * AvmContext execution continues executing instructions until the machine state signals "halted"
-   * */
+   */
   public halted: boolean = false;
   /** Signals that execution has reverted normally (this does not cover exceptional halts) */
   private reverted: boolean = false;
@@ -52,6 +54,28 @@ export class AvmMachineState {
     return new AvmMachineState(state.l1GasLeft, state.l2GasLeft, state.daGasLeft);
   }
 
+  /**
+   * Consumes the given gas.
+   * Should any of the gas dimensions get depleted, it sets all gas left to zero and triggers
+   * an exceptional halt by throwing an OutOfGasError.
+   */
+  public consumeGas(gasCost: Partial<GasCost>) {
+    // Assert there is enough gas on every dimension.
+    const outOfGasDimensions = GasDimensions.filter(
+      dimension => this[`${dimension}Left`] - (gasCost[dimension] ?? 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) {
+      this.exceptionalHalt();
+      throw new OutOfGasError(outOfGasDimensions);
+    }
+    // Otherwise, charge the corresponding gas
+    for (const dimension of GasDimensions) {
+      this[`${dimension}Left`] -= gasCost[dimension] ?? 0;
+    }
+  }
+
   /**
    * Most instructions just increment PC before they complete
    */
@@ -80,6 +104,15 @@ export class AvmMachineState {
     this.output = output;
   }
 
+  /**
+   * Flag an exceptional halt. Clears gas left and sets the reverted flag. No output data.
+   */
+  protected exceptionalHalt() {
+    GasDimensions.forEach(dimension => (this[`${dimension}Left`] = 0));
+    this.reverted = true;
+    this.halted = true;
+  }
+
   /**
    * Get a summary of execution results for a halted machine state
    * @returns summary of execution results

package/src/avm/avm_memory_types.ts

@@ -229,6 +229,7 @@ export class TaggedMemory {
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
     TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
     return value;
   }
 

package/src/avm/avm_simulator.ts

@@ -50,7 +50,6 @@ export class AvmSimulator {
    */
   public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResults> {
     assert(instructions.length > 0);
-
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
@@ -65,7 +64,7 @@ export class AvmSimulator {
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
-        await instruction.execute(this.context);
+        await instruction.run(this.context);
 
         if (this.context.machineState.pc >= instructions.length) {
           this.log('Passed end of program!');

package/src/avm/errors.ts

@@ -55,3 +55,11 @@ export class TagCheckError extends AvmExecutionError {
     this.name = 'TagCheckError';
   }
 }
+
+/** Error thrown when out of gas. */
+export class OutOfGasError extends AvmExecutionError {
+  constructor(dimensions: string[]) {
+    super(`Not enough ${dimensions.map(d => d.toUpperCase()).join(', ')} gas left`);
+    this.name = 'OutOfGasError';
+  }
+}

package/src/avm/fixtures/index.ts

@@ -10,7 +10,7 @@ import merge from 'lodash.merge';
 
 import { CommitmentsDB, MessageLoadOracleInputs, PublicContractsDB, PublicStateDB } from '../../index.js';
 import { AvmContext } from '../avm_context.js';
-import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
+import { AvmContextInputs, AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { AvmMachineState } from '../avm_machine_state.js';
 import { HostStorage } from '../journal/host_storage.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
@@ -85,13 +85,13 @@ export function initGlobalVariables(overrides?: Partial<GlobalVariables>): Globa
 }
 
 /**
- * Create an empty instance of the Machine State where all values are zero, unless overridden in the overrides object
+ * Create an empty instance of the Machine State where all values are set to a large enough amount, unless overridden in the overrides object
  */
 export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
   return AvmMachineState.fromState({
-    l1GasLeft: overrides?.l1GasLeft ?? 0,
-    l2GasLeft: overrides?.l2GasLeft ?? 0,
-    daGasLeft: overrides?.daGasLeft ?? 0,
+    l1GasLeft: overrides?.l1GasLeft ?? 100e6,
+    l2GasLeft: overrides?.l2GasLeft ?? 100e6,
+    daGasLeft: overrides?.daGasLeft ?? 100e6,
   });
 }
 
@@ -113,3 +113,19 @@ export function initL1ToL2MessageOracleInput(
     new SiblingPath(L1_TO_L2_MSG_TREE_HEIGHT, Array(L1_TO_L2_MSG_TREE_HEIGHT)),
   );
 }
+
+/**
+ * Adjust the user index to account for the AvmContextInputs size.
+ * This is a hack for testing, and should go away once AvmContextInputs themselves go away.
+ */
+export function adjustCalldataIndex(userIndex: number): number {
+  return userIndex + AvmContextInputs.SIZE;
+}
+
+export function anyAvmContextInputs() {
+  const tv = [];
+  for (let i = 0; i < AvmContextInputs.SIZE; i++) {
+    tv.push(expect.any(Fr));
+  }
+  return tv;
+}

package/src/avm/journal/journal.ts

@@ -156,7 +156,16 @@ export class AvmPersistableStateManager {
   public async checkL1ToL2MessageExists(msgHash: Fr, msgLeafIndex: Fr): Promise<boolean> {
     let exists = false;
     try {
-      const gotMessage = await this.hostStorage.commitmentsDb.getL1ToL2MembershipWitness(msgHash);
+      // The following 2 values are used to compute a message nullifier. Given that here we do not care about getting
+      // non-nullified messages we can just pass in random values and the nullifier check will effectively be ignored
+      // (no nullifier will be found).
+      const ignoredContractAddress = AztecAddress.random();
+      const ignoredSecret = Fr.random();
+      const gotMessage = await this.hostStorage.commitmentsDb.getL1ToL2MembershipWitness(
+        ignoredContractAddress,
+        msgHash,
+        ignoredSecret,
+      );
       exists = gotMessage !== undefined && gotMessage.index == msgLeafIndex.toBigInt();
     } catch {
       // error getting message - doesn't exist!

package/src/avm/opcodes/addressing_mode.ts

@@ -12,7 +12,7 @@ export enum AddressingMode {
 export class Addressing {
   public constructor(
     /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
-    private readonly modePerOperand: AddressingMode[],
+    public readonly modePerOperand: AddressingMode[],
   ) {
     assert(modePerOperand.length <= 8, 'At most 8 operands are supported');
   }

package/src/avm/opcodes/arithmetic.ts

@@ -1,84 +1,71 @@
 import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag } from '../avm_memory_types.js';
+import { GasCost, GasCostConstants, getGasCostMultiplierFromTypeTag, makeGasCost } from '../avm_gas_cost.js';
+import { Field, MemoryValue, TypeTag } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing, AddressingMode } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
-export class Add extends ThreeOperandInstruction {
-  static readonly type: string = 'ADD';
-  static readonly opcode = Opcode.ADD;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
+export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
   async execute(context: AvmContext): Promise<void> {
     context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
 
     const a = context.machineState.memory.get(this.aOffset);
     const b = context.machineState.memory.get(this.bOffset);
 
-    const dest = a.add(b);
+    const dest = this.compute(a, b);
     context.machineState.memory.set(this.dstOffset, dest);
 
     context.machineState.incrementPc();
   }
-}
 
-export class Sub extends ThreeOperandInstruction {
-  static readonly type: string = 'SUB';
-  static readonly opcode = Opcode.SUB;
+  protected gasCost(): GasCost {
+    const indirectCount = Addressing.fromWire(this.indirect).modePerOperand.filter(
+      mode => mode === AddressingMode.INDIRECT,
+    ).length;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+    const l2Gas =
+      indirectCount * GasCostConstants.ARITHMETIC_COST_PER_INDIRECT_ACCESS +
+      getGasCostMultiplierFromTypeTag(this.inTag) * GasCostConstants.ARITHMETIC_COST_PER_BYTE;
+    return makeGasCost({ l2Gas });
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
+  protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+}
 
-    const dest = a.sub(b);
-    context.machineState.memory.set(this.dstOffset, dest);
+export class Add extends ThreeOperandArithmeticInstruction {
+  static readonly type: string = 'ADD';
+  static readonly opcode = Opcode.ADD;
 
-    context.machineState.incrementPc();
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    return a.add(b);
   }
 }
 
-export class Mul extends ThreeOperandInstruction {
-  static type: string = 'MUL';
-  static readonly opcode = Opcode.MUL;
+export class Sub extends ThreeOperandArithmeticInstruction {
+  static readonly type: string = 'SUB';
+  static readonly opcode = Opcode.SUB;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    return a.sub(b);
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
-
-    const dest = a.mul(b);
-    context.machineState.memory.set(this.dstOffset, dest);
+export class Mul extends ThreeOperandArithmeticInstruction {
+  static type: string = 'MUL';
+  static readonly opcode = Opcode.MUL;
 
-    context.machineState.incrementPc();
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    return a.mul(b);
   }
 }
 
-export class Div extends ThreeOperandInstruction {
+export class Div extends ThreeOperandArithmeticInstruction {
   static type: string = 'DIV';
   static readonly opcode = Opcode.DIV;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
-
-    const dest = a.div(b);
-    context.machineState.memory.set(this.dstOffset, dest);
-
-    context.machineState.incrementPc();
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    return a.div(b);
   }
 }
 

package/src/avm/opcodes/hashing.ts

@@ -23,21 +23,24 @@ export class Poseidon2 extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSize: number,
   ) {
     super();
   }
 
   async execute(context: AvmContext): Promise<void> {
     // We hash a set of field elements
-    const [hashOffset] = Addressing.fromWire(this.indirect).resolve([this.hashOffset], context.machineState.memory);
+    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset],
+      context.machineState.memory,
+    );
 
     // Memory pointer will be indirect
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = poseidonHash(hashData);
-    context.machineState.memory.set(this.dstOffset, new Field(hash));
+    context.machineState.memory.set(dstOffset, new Field(hash));
 
     context.machineState.incrementPc();
   }
@@ -59,8 +62,8 @@ export class Keccak extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSize: number,
   ) {
     super();
   }
@@ -68,12 +71,12 @@ export class Keccak extends Instruction {
   // Note hash output is 32 bytes, so takes up two fields
   async execute(context: AvmContext): Promise<void> {
     // We hash a set of field elements
-    const [hashOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.hashOffset, this.dstOffset],
+    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset],
       context.machineState.memory,
     );
 
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = keccak(Buffer.concat(hashData));
 
@@ -104,21 +107,21 @@ export class Sha256 extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSize: number,
   ) {
     super();
   }
 
   // Note hash output is 32 bytes, so takes up two fields
   async execute(context: AvmContext): Promise<void> {
-    const [hashOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.hashOffset, this.dstOffset],
+    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset],
       context.machineState.memory,
     );
 
     // We hash a set of field elements
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = sha256(Buffer.concat(hashData));
 
@@ -149,21 +152,25 @@ export class Pedersen extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSizeOffset: number,
   ) {
     super();
   }
 
   async execute(context: AvmContext): Promise<void> {
-    const [hashOffset] = Addressing.fromWire(this.indirect).resolve([this.hashOffset], context.machineState.memory);
+    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
+      context.machineState.memory,
+    );
 
     // We hash a set of field elements
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const messageSize = Number(context.machineState.memory.get(messageSizeOffset).toBigInt());
+    const hashData = context.machineState.memory.getSlice(messageOffset, messageSize);
 
     // No domain sep for now
     const hash = pedersenHash(hashData);
-    context.machineState.memory.set(this.dstOffset, new Field(hash));
+    context.machineState.memory.set(dstOffset, new Field(hash));
 
     context.machineState.incrementPc();
   }

package/src/avm/opcodes/instruction.ts

@@ -1,8 +1,9 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
+import { DynamicGasCost, GasCost, GasCosts } from '../avm_gas_cost.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
-import { OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
+import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
 
 type InstructionConstructor = {
   new (...args: any[]): Instruction;
@@ -14,6 +15,28 @@ type InstructionConstructor = {
  * It's most important aspects are execute and (de)serialize.
  */
 export abstract class Instruction {
+  /**
+   * Consumes gas and executes the instruction.
+   * This is the main entry point for the instruction.
+   * @param context - The AvmContext in which the instruction executes.
+   */
+  public run(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+    return this.execute(context);
+  }
+
+  /**
+   * Loads default gas cost for the instruction from the GasCosts table.
+   * Instruction sub-classes can override this if their gas cost is not fixed.
+   */
+  protected gasCost(): GasCost {
+    const gasCost = GasCosts[this.opcode];
+    if (gasCost === DynamicGasCost) {
+      throw new Error(`Instruction ${this.type} must define its own gas cost`);
+    }
+    return gasCost;
+  }
+
   /**
    * Execute the instruction.
    * Instruction sub-classes must implement this.
@@ -21,7 +44,7 @@ export abstract class Instruction {
    * each instruction until the machine state signals "halted".
    * @param context - The AvmContext in which the instruction executes.
    */
-  public abstract execute(context: AvmContext): Promise<void>;
+  protected abstract execute(context: AvmContext): Promise<void>;
 
   /**
    * Generate a string representation of the instruction including
@@ -61,4 +84,28 @@ export abstract class Instruction {
     const args = res.slice(1); // Remove opcode.
     return new this(...args);
   }
+
+  /**
+   * Returns the stringified type of the instruction.
+   * Instruction sub-classes should have a static `type` property.
+   */
+  public get type(): string {
+    const type = 'type' in this.constructor && (this.constructor.type as string);
+    if (!type) {
+      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
+    }
+    return type;
+  }
+
+  /**
+   * Returns the opcode of the instruction.
+   * Instruction sub-classes should have a static `opcode` property.
+   */
+  public get opcode(): Opcode {
+    const opcode = 'opcode' in this.constructor ? (this.constructor.opcode as Opcode) : undefined;
+    if (opcode === undefined || Opcode[opcode] === undefined) {
+      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`);
+    }
+    return opcode;
+  }
 }

package/src/avm/opcodes/memory.ts

@@ -1,4 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
+import { GasCost, GasCostConstants, getGasCostMultiplierFromTypeTag, makeGasCost } from '../avm_gas_cost.js';
 import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
@@ -79,6 +80,10 @@ export class Set extends Instruction {
 
     context.machineState.incrementPc();
   }
+
+  protected gasCost(): GasCost {
+    return makeGasCost({ l2Gas: GasCostConstants.SET_COST_PER_BYTE * getGasCostMultiplierFromTypeTag(this.inTag) });
+  }
 }
 
 export class CMov extends Instruction {
@@ -193,4 +198,8 @@ export class CalldataCopy extends Instruction {
 
     context.machineState.incrementPc();
   }
+
+  protected gasCost(): GasCost {
+    return makeGasCost({ l2Gas: GasCostConstants.CALLDATACOPY_COST_PER_BYTE * this.copySize });
+  }
 }

package/src/avm/temporary_executor_migration.ts

@@ -1,5 +1,5 @@
 // All code in this file needs to die once the public executor is phased out.
-import { FunctionL2Logs } from '@aztec/circuit-types';
+import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
   ContractStorageRead,
   ContractStorageUpdateRequest,
@@ -96,7 +96,7 @@ export function temporaryConvertAvmResults(
   const nullifierReadRequests: ReadRequest[] = [];
   const nullifierNonExistentReadRequests: ReadRequest[] = [];
   const newNullifiers: SideEffectLinkedToNoteHash[] = [];
-  const unencryptedLogs = FunctionL2Logs.empty();
+  const unencryptedLogs = UnencryptedFunctionL2Logs.empty();
   const newL2ToL1Messages = newWorldState.newL1Messages.map(() => L2ToL1Message.empty());
   // TODO keep track of side effect counters
   const startSideEffectCounter = Fr.ZERO;