@aztec/simulator 0.32.1 → 0.33.0

package/src/avm/opcodes/environment_getters.ts

@@ -2,136 +2,127 @@ import { type Fr } from '@aztec/circuits.js';
 
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field } from '../avm_memory_types.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Instruction } from './instruction.js';
+import { Field, type MemoryValue } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { GetterInstruction } from './instruction_impl.js';
 
-abstract class GetterInstruction extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
-
-  constructor(protected indirect: number, protected dstOffset: number) {
-    super();
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    const res = new Field(this.getIt(context.environment));
-    context.machineState.memory.set(this.dstOffset, res);
-    context.machineState.incrementPc();
+abstract class EnvironmentGetterInstruction extends GetterInstruction {
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(this.getEnvironmentValue(context.environment));
   }
 
-  protected abstract getIt(env: AvmExecutionEnvironment): Fr | number | bigint;
+  protected abstract getEnvironmentValue(env: AvmExecutionEnvironment): Fr | number | bigint;
 }
 
-export class Address extends GetterInstruction {
+export class Address extends EnvironmentGetterInstruction {
   static type: string = 'ADDRESS';
   static readonly opcode: Opcode = Opcode.ADDRESS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.address;
   }
 }
 
-export class StorageAddress extends GetterInstruction {
+export class StorageAddress extends EnvironmentGetterInstruction {
   static type: string = 'STORAGEADDRESS';
   static readonly opcode: Opcode = Opcode.STORAGEADDRESS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.storageAddress;
   }
 }
 
-export class Sender extends GetterInstruction {
+export class Sender extends EnvironmentGetterInstruction {
   static type: string = 'SENDER';
   static readonly opcode: Opcode = Opcode.SENDER;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.sender;
   }
 }
 
-export class Origin extends GetterInstruction {
+export class Origin extends EnvironmentGetterInstruction {
   static type: string = 'ORIGIN';
   static readonly opcode: Opcode = Opcode.ORIGIN;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.origin;
   }
 }
 
-export class FeePerL1Gas extends GetterInstruction {
+export class FeePerL1Gas extends EnvironmentGetterInstruction {
   static type: string = 'FEEPERL1GAS';
   static readonly opcode: Opcode = Opcode.FEEPERL1GAS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.feePerL1Gas;
   }
 }
 
-export class FeePerL2Gas extends GetterInstruction {
+export class FeePerL2Gas extends EnvironmentGetterInstruction {
   static type: string = 'FEEPERL2GAS';
   static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.feePerL2Gas;
   }
 }
 
-export class FeePerDAGas extends GetterInstruction {
+export class FeePerDAGas extends EnvironmentGetterInstruction {
   static type: string = 'FEEPERDAGAS';
   static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.feePerDaGas;
   }
 }
 
-export class Portal extends GetterInstruction {
+export class Portal extends EnvironmentGetterInstruction {
   static type: string = 'PORTAL';
   static readonly opcode: Opcode = Opcode.PORTAL;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.portal.toField();
   }
 }
 
-export class ChainId extends GetterInstruction {
+export class ChainId extends EnvironmentGetterInstruction {
   static type: string = 'CHAINID';
   static readonly opcode: Opcode = Opcode.CHAINID;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.chainId;
   }
 }
 
-export class Version extends GetterInstruction {
+export class Version extends EnvironmentGetterInstruction {
   static type: string = 'VERSION';
   static readonly opcode: Opcode = Opcode.VERSION;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.version;
   }
 }
 
-export class BlockNumber extends GetterInstruction {
+export class BlockNumber extends EnvironmentGetterInstruction {
   static type: string = 'BLOCKNUMBER';
   static readonly opcode: Opcode = Opcode.BLOCKNUMBER;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.blockNumber;
   }
 }
 
-export class Timestamp extends GetterInstruction {
+export class Timestamp extends EnvironmentGetterInstruction {
   static type: string = 'TIMESTAMP';
   static readonly opcode: Opcode = Opcode.TIMESTAMP;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.timestamp;
   }
 }
 
-// export class Coinbase extends GetterInstruction {
+// export class Coinbase extends EnvironmentGetterInstruction {
 //     static type: string = 'COINBASE';
 //     static numberOfOperands = 1;
 
@@ -149,7 +140,7 @@ export class Timestamp extends GetterInstruction {
 // }
 
 // // TODO: are these even needed within the block? (both block gas limit variables - why does the execution env care?)
-// export class BlockL1GasLimit extends GetterInstruction {
+// export class BlockL1GasLimit extends EnvironmentGetterInstruction {
 //     static type: string = 'BLOCKL1GASLIMIT';
 //     static numberOfOperands = 1;
 
@@ -166,7 +157,7 @@ export class Timestamp extends GetterInstruction {
 //     }
 // }
 
-// export class BlockL2GasLimit extends GetterInstruction {
+// export class BlockL2GasLimit extends EnvironmentGetterInstruction {
 //     static type: string = 'BLOCKL2GASLIMIT';
 //     static numberOfOperands = 1;
 
@@ -183,7 +174,7 @@ export class Timestamp extends GetterInstruction {
 //     }
 // }
 
-// export class BlockDAGasLimit extends GetterInstruction {
+// export class BlockDAGasLimit extends EnvironmentGetterInstruction {
 //     static type: string = 'BLOCKDAGASLIMIT';
 //     static numberOfOperands = 1;
 

package/src/avm/opcodes/external_calls.ts

@@ -1,15 +1,15 @@
 import { FunctionSelector } from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
 
 import type { AvmContext } from '../avm_context.js';
+import { gasLeftToGas, sumGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
-export class Call extends Instruction {
-  static type: string = 'CALL';
-  static readonly opcode: Opcode = Opcode.CALL;
+abstract class ExternalCall extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
@@ -27,7 +27,7 @@ export class Call extends Instruction {
 
   constructor(
     private indirect: number,
-    private _gasOffset: number /* Unused due to no formal gas implementation at this moment */,
+    private gasOffset: number /* Unused due to no formal gas implementation at this moment */,
     private addrOffset: number,
     private argsOffset: number,
     private argsSize: number,
@@ -42,110 +42,81 @@ export class Call extends Instruction {
     super();
   }
 
-  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3992): there is no concept of remaining / available gas at this moment
-  async execute(context: AvmContext): Promise<void> {
-    const [_gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this._gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
-      context.machineState.memory,
+  public async execute(context: AvmContext) {
+    const memory = context.machineState.memory.track(this.type);
+    const [gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
+      memory,
     );
 
-    const callAddress = context.machineState.memory.getAs<Field>(addrOffset);
-    const calldata = context.machineState.memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
-    const functionSelector = context.machineState.memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
+    const callAddress = memory.getAs<Field>(addrOffset);
+    const calldata = memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
+    const l1Gas = memory.get(gasOffset).toNumber();
+    const l2Gas = memory.getAs<Field>(gasOffset + 1).toNumber();
+    const daGas = memory.getAs<Field>(gasOffset + 2).toNumber();
+    const functionSelector = memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
+
+    const allocatedGas = { l1Gas, l2Gas, daGas };
+    const memoryOperations = { reads: this.argsSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
+    const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
+    context.machineState.consumeGas(totalGas);
 
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
+      allocatedGas,
+      this.type,
       FunctionSelector.fromField(functionSelector),
     );
 
     const nestedCallResults = await new AvmSimulator(nestedContext).execute();
     const success = !nestedCallResults.reverted;
 
-    // We only take as much data as was specified in the return size -> TODO: should we be reverting here
+    // We only take as much data as was specified in the return size and pad with zeroes if the return data is smaller
+    // than the specified size in order to prevent that memory to be left with garbage
     const returnData = nestedCallResults.output.slice(0, this.retSize);
-    const convertedReturnData = returnData.map(f => new Field(f));
+    const convertedReturnData = padArrayEnd(
+      returnData.map(f => new Field(f)),
+      new Field(0),
+      this.retSize,
+    );
 
     // Write our return data into memory
-    context.machineState.memory.set(successOffset, new Uint8(success ? 1 : 0));
-    context.machineState.memory.setSlice(retOffset, convertedReturnData);
+    memory.set(successOffset, new Uint8(success ? 1 : 0));
+    memory.setSlice(retOffset, convertedReturnData);
+
+    // Refund unused gas
+    context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
 
+    // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
     if (success) {
       context.persistableState.acceptNestedCallState(nestedContext.persistableState);
     } else {
       context.persistableState.rejectNestedCallState(nestedContext.persistableState);
     }
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  public abstract get type(): 'CALL' | 'STATICCALL';
 }
 
-export class StaticCall extends Instruction {
-  static type: string = 'STATICCALL';
-  static readonly opcode: Opcode = Opcode.STATICCALL;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    /* temporary function selector */
-    OperandType.UINT32,
-  ];
+export class Call extends ExternalCall {
+  static type = 'CALL' as const;
+  static readonly opcode: Opcode = Opcode.CALL;
 
-  constructor(
-    private indirect: number,
-    private _gasOffset: number /* Unused due to no formal gas implementation at this moment */,
-    private addrOffset: number,
-    private argsOffset: number,
-    private argsSize: number,
-    private retOffset: number,
-    private retSize: number,
-    private successOffset: number,
-    private temporaryFunctionSelectorOffset: number,
-  ) {
-    super();
+  public get type() {
+    return Call.type;
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    const [_gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this._gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
-      context.machineState.memory,
-    );
-
-    const callAddress = context.machineState.memory.get(addrOffset);
-    const calldata = context.machineState.memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
-    const functionSelector = context.machineState.memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
-
-    const nestedContext = context.createNestedContractStaticCallContext(
-      callAddress.toFr(),
-      calldata,
-      FunctionSelector.fromField(functionSelector),
-    );
-
-    const nestedCallResults = await new AvmSimulator(nestedContext).execute();
-    const success = !nestedCallResults.reverted;
-
-    // We only take as much data as was specified in the return size -> TODO: should we be reverting here
-    const returnData = nestedCallResults.output.slice(0, this.retSize);
-    const convertedReturnData = returnData.map(f => new Field(f));
-
-    // Write our return data into memory
-    context.machineState.memory.set(successOffset, new Uint8(success ? 1 : 0));
-    context.machineState.memory.setSlice(retOffset, convertedReturnData);
-
-    if (success) {
-      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
-    } else {
-      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
-    }
+export class StaticCall extends ExternalCall {
+  static type = 'STATICCALL' as const;
+  static readonly opcode: Opcode = Opcode.STATICCALL;
 
-    context.machineState.incrementPc();
+  public get type() {
+    return StaticCall.type;
   }
 }
 
@@ -164,12 +135,17 @@ export class Return extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], context.machineState.memory);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.copySize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
 
-    const output = context.machineState.memory.getSlice(returnOffset, this.copySize).map(word => word.toFr());
+    const output = memory.getSlice(returnOffset, this.copySize).map(word => word.toFr());
 
     context.machineState.return(output);
+    memory.assert(memoryOperations);
   }
 }
 
@@ -188,11 +164,16 @@ export class Revert extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], context.machineState.memory);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.retSize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
 
-    const output = context.machineState.memory.getSlice(returnOffset, this.retSize).map(word => word.toFr());
+    const output = memory.getSlice(returnOffset, this.retSize).map(word => word.toFr());
 
     context.machineState.revert(output);
+    memory.assert(memoryOperations);
   }
 }

package/src/avm/opcodes/hashing.ts

@@ -29,19 +29,24 @@ export class Poseidon2 extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.messageSize, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // We hash a set of field elements
     const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.dstOffset, this.messageOffset],
-      context.machineState.memory,
+      memory,
     );
 
     // Memory pointer will be indirect
-    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
+    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = poseidonHash(hashData);
-    context.machineState.memory.set(dstOffset, new Field(hash));
+    memory.set(dstOffset, new Field(hash));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -69,14 +74,18 @@ export class Keccak extends Instruction {
   }
 
   // Note hash output is 32 bytes, so takes up two fields
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // We hash a set of field elements
     const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.dstOffset, this.messageOffset],
-      context.machineState.memory,
+      memory,
     );
 
-    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
+    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = keccak(Buffer.concat(hashData));
 
@@ -84,9 +93,10 @@ export class Keccak extends Instruction {
     const high = new Field(toBigIntBE(hash.subarray(0, 16)));
     const low = new Field(toBigIntBE(hash.subarray(16, 32)));
 
-    context.machineState.memory.set(dstOffset, high);
-    context.machineState.memory.set(dstOffset + 1, low);
+    memory.set(dstOffset, high);
+    memory.set(dstOffset + 1, low);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -114,14 +124,18 @@ export class Sha256 extends Instruction {
   }
 
   // Note hash output is 32 bytes, so takes up two fields
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.dstOffset, this.messageOffset],
-      context.machineState.memory,
+      memory,
     );
 
     // We hash a set of field elements
-    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
+    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = sha256(Buffer.concat(hashData));
 
@@ -129,9 +143,10 @@ export class Sha256 extends Instruction {
     const high = new Field(toBigIntBE(hash.subarray(0, 16)));
     const low = new Field(toBigIntBE(hash.subarray(16, 32)));
 
-    context.machineState.memory.set(dstOffset, high);
-    context.machineState.memory.set(dstOffset + 1, low);
+    memory.set(dstOffset, high);
+    memory.set(dstOffset + 1, low);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -147,10 +162,12 @@ export class Pedersen extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
+    OperandType.UINT32,
   ];
 
   constructor(
     private indirect: number,
+    private genIndexOffset: number,
     private dstOffset: number,
     private messageOffset: number,
     private messageSizeOffset: number,
@@ -158,20 +175,26 @@ export class Pedersen extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
-      context.machineState.memory,
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const [genIndexOffset, dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.genIndexOffset, this.dstOffset, this.messageOffset, this.messageSizeOffset],
+      memory,
     );
 
     // We hash a set of field elements
-    const messageSize = Number(context.machineState.memory.get(messageSizeOffset).toBigInt());
-    const hashData = context.machineState.memory.getSlice(messageOffset, messageSize);
+    const genIndex = Number(memory.get(genIndexOffset).toBigInt());
+    const messageSize = Number(memory.get(messageSizeOffset).toBigInt());
+    const hashData = memory.getSlice(messageOffset, messageSize);
+
+    const memoryOperations = { reads: messageSize + 2, writes: 1, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     // No domain sep for now
-    const hash = pedersenHash(hashData);
-    context.machineState.memory.set(dstOffset, new Field(hash));
+    const hash = pedersenHash(hashData, genIndex);
+    memory.set(dstOffset, new Field(hash));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/index.ts

@@ -1,6 +1,7 @@
 export * from './arithmetic.js';
 export * from './bitwise.js';
 export * from './control_flow.js';
+export * from './contract.js';
 export * from './instruction.js';
 export * from './comparators.js';
 export * from './memory.js';

package/src/avm/opcodes/instruction.ts

@@ -1,7 +1,8 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { DynamicGasCost, type GasCost, GasCosts } from '../avm_gas_cost.js';
+import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
+import { type MemoryOperations } from '../avm_memory_types.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
 
@@ -20,31 +21,7 @@ export abstract class 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.
-   * As an AvmContext executes its contract code, it calls this function for
-   * each instruction until the machine state signals "halted".
-   * @param context - The AvmContext in which the instruction executes.
-   */
-  protected abstract execute(context: AvmContext): Promise<void>;
+  public abstract execute(context: AvmContext): Promise<void>;
 
   /**
    * Generate a string representation of the instruction including
@@ -85,6 +62,17 @@ export abstract class Instruction {
     return new this(...args);
   }
 
+  /**
+   * Computes gas cost for the instruction based on its base cost and memory operations.
+   * @param memoryOps Memory operations performed by the instruction.
+   * @returns Gas cost.
+   */
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+    const baseGasCost = getBaseGasCost(this.opcode);
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
+  }
+
   /**
    * Returns the stringified type of the instruction.
    * Instruction sub-classes should have a static `type` property.