@aztec/simulator 0.32.1 → 0.34.0

package/src/avm/journal/trace_types.ts

@@ -6,64 +6,64 @@ import { type Fr } from '@aztec/foundation/fields';
 //  storageAddress: Fr;
 //  endLifetime: Fr;
 //};
-//
-//export type TracedPublicStorageRead = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  exists: boolean;
-//  slot: Fr;
-//  value: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
-//
-//export type TracedPublicStorageWrite = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  slot: Fr;
-//  value: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
-//
+
+export type TracedPublicStorageRead = {
+  //  callPointer: Fr;
+  storageAddress: Fr;
+  exists: boolean;
+  slot: Fr;
+  value: Fr;
+  counter: Fr;
+  //  endLifetime: Fr;
+};
+
+export type TracedPublicStorageWrite = {
+  //  callPointer: Fr;
+  storageAddress: Fr;
+  slot: Fr;
+  value: Fr;
+  counter: Fr;
+  //  endLifetime: Fr;
+};
+
 export type TracedNoteHashCheck = {
-  callPointer: Fr;
+  // callPointer: Fr;
   storageAddress: Fr;
   leafIndex: Fr;
   noteHash: Fr;
   exists: boolean;
   counter: Fr;
-  endLifetime: Fr;
+  // endLifetime: Fr;
+};
+
+export type TracedNoteHash = {
+  //  callPointer: Fr;
+  storageAddress: Fr;
+  noteHash: Fr;
+  counter: Fr;
+  //  endLifetime: Fr;
 };
-//
-//export type TracedNoteHash = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  noteHash: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
 
 export type TracedNullifierCheck = {
-  callPointer: Fr;
+  // callPointer: Fr;
   storageAddress: Fr;
   nullifier: Fr;
   exists: boolean;
   counter: Fr;
-  endLifetime: Fr;
+  // endLifetime: Fr;
   // the fields below are relevant only to the public kernel
   // and are therefore omitted from VM inputs
   isPending: boolean;
   leafIndex: Fr;
 };
 
-//export type TracedNullifier = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  nullifier: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
+export type TracedNullifier = {
+  // callPointer: Fr;
+  storageAddress: Fr;
+  nullifier: Fr;
+  counter: Fr;
+  // endLifetime: Fr;
+};
 
 export type TracedL1toL2MessageCheck = {
   //callPointer: Fr;

package/src/avm/opcodes/accrued_substate.ts

@@ -28,18 +28,23 @@ export class NoteHashExists extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // Note that this instruction accepts any type in memory, and converts to Field.
-    const noteHash = context.machineState.memory.get(this.noteHashOffset).toFr();
-    const leafIndex = context.machineState.memory.get(this.leafIndexOffset).toFr();
+    const noteHash = memory.get(this.noteHashOffset).toFr();
+    const leafIndex = memory.get(this.leafIndexOffset).toFr();
 
     const exists = await context.persistableState.checkNoteHashExists(
       context.environment.storageAddress,
       noteHash,
       leafIndex,
     );
-    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -54,14 +59,19 @@ export class EmitNoteHash extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const noteHash = context.machineState.memory.get(this.noteHashOffset).toFr();
-    context.persistableState.writeNoteHash(noteHash);
+    const noteHash = memory.get(this.noteHashOffset).toFr();
+    context.persistableState.writeNoteHash(context.environment.storageAddress, noteHash);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -76,12 +86,17 @@ export class NullifierExists extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const nullifier = context.machineState.memory.get(this.nullifierOffset).toFr();
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const nullifier = memory.get(this.nullifierOffset).toFr();
     const exists = await context.persistableState.checkNullifierExists(context.environment.storageAddress, nullifier);
 
-    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -96,12 +111,16 @@ export class EmitNullifier extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const nullifier = context.machineState.memory.get(this.nullifierOffset).toFr();
+    const memoryOperations = { reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const nullifier = memory.get(this.nullifierOffset).toFr();
     try {
       await context.persistableState.writeNullifier(context.environment.storageAddress, nullifier);
     } catch (e) {
@@ -115,6 +134,7 @@ export class EmitNullifier extends Instruction {
       }
     }
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -140,12 +160,17 @@ export class L1ToL2MessageExists extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const msgHash = context.machineState.memory.get(this.msgHashOffset).toFr();
-    const msgLeafIndex = context.machineState.memory.get(this.msgLeafIndexOffset).toFr();
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const msgHash = memory.get(this.msgHashOffset).toFr();
+    const msgLeafIndex = memory.get(this.msgLeafIndexOffset).toFr();
     const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
-    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -171,21 +196,26 @@ export class EmitUnencryptedLog extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
+    const memoryOperations = { reads: 1 + this.logSize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     const [eventSelectorOffset, logOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.eventSelectorOffset, this.logOffset],
-      context.machineState.memory,
+      memory,
     );
 
     const contractAddress = context.environment.address;
-    const event = context.machineState.memory.get(eventSelectorOffset).toFr();
-    const log = context.machineState.memory.getSlice(logOffset, this.logSize).map(f => f.toFr());
+    const event = memory.get(eventSelectorOffset).toFr();
+    const log = memory.getSlice(logOffset, this.logSize).map(f => f.toFr());
     context.persistableState.writeLog(contractAddress, event, log);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -200,15 +230,20 @@ export class SendL2ToL1Message extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const recipient = context.machineState.memory.get(this.recipientOffset).toFr();
-    const content = context.machineState.memory.get(this.contentOffset).toFr();
+    const memoryOperations = { reads: 2, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const recipient = memory.get(this.recipientOffset).toFr();
+    const content = memory.get(this.contentOffset).toFr();
     context.persistableState.writeL1Message(recipient, content);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/addressing_mode.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert';
 
-import { type TaggedMemory } from '../avm_memory_types.js';
+import { type TaggedMemoryInterface } from '../avm_memory_types.js';
 
 export enum AddressingMode {
   DIRECT,
@@ -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. */
-    public readonly modePerOperand: AddressingMode[],
+    private readonly modePerOperand: AddressingMode[],
   ) {
     assert(modePerOperand.length <= 8, 'At most 8 operands are supported');
   }
@@ -39,13 +39,18 @@ export class Addressing {
     return wire;
   }
 
+  /** Returns how many operands use the given addressing mode. */
+  public count(mode: AddressingMode): number {
+    return this.modePerOperand.filter(m => m === mode).length;
+  }
+
   /**
    * Resolves the offsets using the addressing mode.
    * @param offsets The offsets to resolve.
    * @param mem The memory to use for resolution.
    * @returns The resolved offsets. The length of the returned array is the same as the length of the input array.
    */
-  public resolve(offsets: number[], mem: TaggedMemory): number[] {
+  public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
     assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
     for (const [i, offset] of offsets.entries()) {

package/src/avm/opcodes/arithmetic.ts

@@ -1,33 +1,32 @@
 import type { AvmContext } from '../avm_context.js';
-import { type GasCost, GasCostConstants, getGasCostMultiplierFromTypeTag, makeGasCost } from '../avm_gas_cost.js';
-import { type Field, type MemoryValue, TypeTag } from '../avm_memory_types.js';
+import { getBaseGasCost, getGasCostForTypeTag, getMemoryGasCost, sumGas } from '../avm_gas.js';
+import { type Field, type MemoryOperations, type 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 abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
+    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = memory.get(this.aOffset);
+    const b = memory.get(this.bOffset);
 
     const dest = this.compute(a, b);
-    context.machineState.memory.set(this.dstOffset, dest);
+    memory.set(this.dstOffset, dest);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 
-  protected gasCost(): GasCost {
-    const indirectCount = Addressing.fromWire(this.indirect).modePerOperand.filter(
-      mode => mode === AddressingMode.INDIRECT,
-    ).length;
-
-    const l2Gas =
-      indirectCount * GasCostConstants.ARITHMETIC_COST_PER_INDIRECT_ACCESS +
-      getGasCostMultiplierFromTypeTag(this.inTag) * GasCostConstants.ARITHMETIC_COST_PER_BYTE;
-    return makeGasCost({ l2Gas });
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
+    const baseGasCost = getGasCostForTypeTag(this.inTag, getBaseGasCost(this.opcode));
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
   }
 
   protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
@@ -86,15 +85,26 @@ export class FieldDiv extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(TypeTag.FIELD, this.aOffset, this.bOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    memory.checkTags(TypeTag.FIELD, this.aOffset, this.bOffset);
 
-    const a = context.machineState.memory.getAs<Field>(this.aOffset);
-    const b = context.machineState.memory.getAs<Field>(this.bOffset);
+    const a = memory.getAs<Field>(this.aOffset);
+    const b = memory.getAs<Field>(this.bOffset);
 
     const dest = a.fdiv(b);
-    context.machineState.memory.set(this.dstOffset, dest);
+    memory.set(this.dstOffset, dest);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
+    const baseGasCost = getGasCostForTypeTag(TypeTag.FIELD, getBaseGasCost(this.opcode));
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
+  }
 }

package/src/avm/opcodes/bitwise.ts

@@ -3,66 +3,69 @@ import { type IntegralValue } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction, TwoOperandInstruction } from './instruction_impl.js';
 
-export class And extends ThreeOperandInstruction {
-  static readonly type: string = 'AND';
-  static readonly opcode = Opcode.AND;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
+abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+    const a = memory.getAs<IntegralValue>(this.aOffset);
+    const b = memory.getAs<IntegralValue>(this.bOffset);
 
-    const res = a.and(b);
-    context.machineState.memory.set(this.dstOffset, res);
+    const res = this.compute(a, b);
+    memory.set(this.dstOffset, res);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
 }
 
-export class Or extends ThreeOperandInstruction {
-  static readonly type: string = 'OR';
-  static readonly opcode = Opcode.OR;
+export class And extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'AND';
+  static readonly opcode = Opcode.AND;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.and(b);
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
-
-    const res = a.or(b);
-    context.machineState.memory.set(this.dstOffset, res);
+export class Or extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'OR';
+  static readonly opcode = Opcode.OR;
 
-    context.machineState.incrementPc();
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.or(b);
   }
 }
 
-export class Xor extends ThreeOperandInstruction {
+export class Xor extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'XOR';
   static readonly opcode = Opcode.XOR;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.xor(b);
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+export class Shl extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'SHL';
+  static readonly opcode = Opcode.SHL;
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.shl(b);
+  }
+}
 
-    const res = a.xor(b);
-    context.machineState.memory.set(this.dstOffset, res);
+export class Shr extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'SHR';
+  static readonly opcode = Opcode.SHR;
 
-    context.machineState.incrementPc();
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.shr(b);
   }
 }
 
@@ -74,56 +77,19 @@ export class Not extends TwoOperandInstruction {
     super(indirect, inTag, aOffset, dstOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset);
-
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-
-    const res = a.not();
-    context.machineState.memory.set(this.dstOffset, res);
-
-    context.machineState.incrementPc();
-  }
-}
-
-export class Shl extends ThreeOperandInstruction {
-  static readonly type: string = 'SHL';
-  static readonly opcode = Opcode.SHL;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+    memory.checkTags(this.inTag, this.aOffset);
 
-    const res = a.shl(b);
-    context.machineState.memory.set(this.dstOffset, res);
+    const a = memory.getAs<IntegralValue>(this.aOffset);
 
-    context.machineState.incrementPc();
-  }
-}
-
-export class Shr extends ThreeOperandInstruction {
-  static readonly type: string = 'SHR';
-  static readonly opcode = Opcode.SHR;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
-
-    const res = a.shr(b);
-    context.machineState.memory.set(this.dstOffset, res);
+    const res = a.not();
+    memory.set(this.dstOffset, res);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/comparators.ts

@@ -1,67 +1,52 @@
 import type { AvmContext } from '../avm_context.js';
-import { Uint8 } from '../avm_memory_types.js';
+import { type MemoryValue, Uint8 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
-export class Eq extends ThreeOperandInstruction {
-  static readonly type: string = 'EQ';
-  static readonly opcode = Opcode.EQ;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
+abstract class ComparatorInstruction extends ThreeOperandInstruction {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    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 a = memory.get(this.aOffset);
+    const b = memory.get(this.bOffset);
 
-    const dest = new Uint8(a.equals(b) ? 1 : 0);
-    context.machineState.memory.set(this.dstOffset, dest);
+    const dest = new Uint8(this.compare(a, b) ? 1 : 0);
+    memory.set(this.dstOffset, dest);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;
 }
 
-export class Lt extends ThreeOperandInstruction {
-  static readonly type: string = 'LT';
-  static readonly opcode = Opcode.LT;
+export class Eq extends ComparatorInstruction {
+  static readonly type: string = 'EQ';
+  static readonly opcode = Opcode.EQ;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.equals(b);
   }
+}
 
-  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 = new Uint8(a.lt(b) ? 1 : 0);
-    context.machineState.memory.set(this.dstOffset, dest);
+export class Lt extends ComparatorInstruction {
+  static readonly type: string = 'LT';
+  static readonly opcode = Opcode.LT;
 
-    context.machineState.incrementPc();
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.lt(b);
   }
 }
 
-export class Lte extends ThreeOperandInstruction {
+export class Lte extends ComparatorInstruction {
   static readonly type: string = 'LTE';
   static readonly opcode = Opcode.LTE;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
-  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 = new Uint8(a.lt(b) || a.equals(b) ? 1 : 0);
-    context.machineState.memory.set(this.dstOffset, dest);
-
-    context.machineState.incrementPc();
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.lt(b) || a.equals(b);
   }
 }