@aztec/simulator 0.23.0 → 0.26.1

package/src/avm/journal/trace.ts

@@ -0,0 +1,223 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import { TracedL1toL2MessageCheck, TracedNoteHashCheck, TracedNullifierCheck } from './trace_types.js';
+
+export class WorldStateAccessTrace {
+  public accessCounter: number;
+  //public contractCalls: Array<TracedContractCall> = [];
+
+  //public publicStorageReads: Array<TracedPublicStorageRead> = [];
+  public publicStorageReads: Map<bigint, Map<bigint, Fr[]>> = new Map();
+  //public publicStorageWrites: Array<TracedPublicStorageWrite> = [];
+  public publicStorageWrites: Map<bigint, Map<bigint, Fr[]>> = new Map();
+
+  public noteHashChecks: TracedNoteHashCheck[] = [];
+  //public newNoteHashes: TracedNoteHash[] = [];
+  public newNoteHashes: Fr[] = [];
+  public nullifierChecks: TracedNullifierCheck[] = [];
+  //public newNullifiers: TracedNullifier[] = [];
+  public newNullifiers: Fr[] = [];
+  public l1ToL2MessageChecks: TracedL1toL2MessageCheck[] = [];
+  //public archiveChecks: TracedArchiveLeafCheck[] = [];
+
+  constructor(parentTrace?: WorldStateAccessTrace) {
+    this.accessCounter = parentTrace ? parentTrace.accessCounter : 0;
+  }
+
+  public getAccessCounter() {
+    return this.accessCounter;
+  }
+
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr /*, _exists: boolean*/) {
+    // TODO(4805): check if some threshold is reached for max storage reads
+    // (need access to parent length, or trace needs to be initialized with parent's contents)
+    //const traced: TracedPublicStorageRead = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  slot,
+    //  value,
+    //  exists,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.publicStorageReads.push(traced);
+    this.journalRead(storageAddress, slot, value);
+    this.incrementAccessCounter();
+  }
+
+  public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
+    // TODO(4805): check if some threshold is reached for max storage writes
+    // (need access to parent length, or trace needs to be initialized with parent's contents)
+    //const traced: TracedPublicStorageWrite = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  slot,
+    //  value,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.publicStorageWrites.push(traced);
+    this.journalWrite(storageAddress, slot, value);
+    this.incrementAccessCounter();
+  }
+
+  public traceNoteHashCheck(storageAddress: Fr, noteHash: Fr, exists: boolean, leafIndex: Fr) {
+    const traced: TracedNoteHashCheck = {
+      callPointer: Fr.ZERO, // FIXME
+      storageAddress,
+      noteHash,
+      exists,
+      counter: new Fr(this.accessCounter),
+      endLifetime: Fr.ZERO,
+      leafIndex,
+    };
+    this.noteHashChecks.push(traced);
+    this.incrementAccessCounter();
+  }
+
+  public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
+    // TODO(4805): check if some threshold is reached for max new note hash
+    //const traced: TracedNoteHash = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  noteHash,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.newNoteHashes.push(traced);
+    this.newNoteHashes.push(noteHash);
+    this.incrementAccessCounter();
+  }
+
+  public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, exists: boolean, isPending: boolean, leafIndex: Fr) {
+    // TODO(4805): check if some threshold is reached for max new nullifier
+    const traced: TracedNullifierCheck = {
+      callPointer: Fr.ZERO, // FIXME
+      storageAddress,
+      nullifier,
+      exists,
+      counter: new Fr(this.accessCounter),
+      endLifetime: Fr.ZERO,
+      isPending,
+      leafIndex,
+    };
+    this.nullifierChecks.push(traced);
+    this.incrementAccessCounter();
+  }
+
+  public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
+    // TODO(4805): check if some threshold is reached for max new nullifier
+    //const traced: TracedNullifier = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  nullifier,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.newNullifiers.push(traced);
+    this.newNullifiers.push(nullifier);
+    this.incrementAccessCounter();
+  }
+
+  public traceL1ToL2MessageCheck(msgHash: Fr, msgLeafIndex: Fr, exists: boolean) {
+    // TODO(4805): check if some threshold is reached for max message reads
+    const traced: TracedL1toL2MessageCheck = {
+      //callPointer: Fr.ZERO, // FIXME
+      leafIndex: msgLeafIndex,
+      msgHash: msgHash,
+      exists: exists,
+      //endLifetime: Fr.ZERO, // FIXME
+    };
+    this.l1ToL2MessageChecks.push(traced);
+    this.incrementAccessCounter();
+  }
+
+  private incrementAccessCounter() {
+    this.accessCounter++;
+  }
+
+  /**
+   * Merges another trace into this one
+   *
+   * - Public state journals (r/w logs), with the accessing being appended in chronological order
+   * - Utxo objects are concatenated
+   *
+   * @param incomingTrace - the incoming trace to merge into this instance
+   */
+  public acceptAndMerge(incomingTrace: WorldStateAccessTrace) {
+    // Merge storage read and write journals
+    mergeContractJournalMaps(this.publicStorageReads, incomingTrace.publicStorageReads);
+    mergeContractJournalMaps(this.publicStorageWrites, incomingTrace.publicStorageWrites);
+    // Merge new note hashes and nullifiers
+    this.noteHashChecks = this.noteHashChecks.concat(incomingTrace.noteHashChecks);
+    this.newNoteHashes = this.newNoteHashes.concat(incomingTrace.newNoteHashes);
+    this.nullifierChecks = this.nullifierChecks.concat(incomingTrace.nullifierChecks);
+    this.newNullifiers = this.newNullifiers.concat(incomingTrace.newNullifiers);
+    this.l1ToL2MessageChecks = this.l1ToL2MessageChecks.concat(incomingTrace.l1ToL2MessageChecks);
+    // it is assumed that the incoming trace was initialized with this as parent, so accept counter
+    this.accessCounter = incomingTrace.accessCounter;
+  }
+
+  /**
+   * We want to keep track of all performed reads in the journal
+   * This information is hinted to the avm circuit
+
+   * @param contractAddress -
+   * @param key -
+   * @param value -
+   */
+  journalUpdate(map: Map<bigint, Map<bigint, Fr[]>>, contractAddress: Fr, key: Fr, value: Fr): void {
+    let contractMap = map.get(contractAddress.toBigInt());
+    if (!contractMap) {
+      contractMap = new Map<bigint, Array<Fr>>();
+      map.set(contractAddress.toBigInt(), contractMap);
+    }
+
+    let accessArray = contractMap.get(key.toBigInt());
+    if (!accessArray) {
+      accessArray = new Array<Fr>();
+      contractMap.set(key.toBigInt(), accessArray);
+    }
+    accessArray.push(value);
+  }
+
+  // Create an instance of journalUpdate that appends to the read array
+  private journalRead = this.journalUpdate.bind(this, this.publicStorageReads);
+  // Create an instance of journalUpdate that appends to the writes array
+  private journalWrite = this.journalUpdate.bind(this, this.publicStorageWrites);
+}
+
+/**
+ * Merges two contract journalling maps together
+ * For read maps, we just append the childMap arrays into the host map arrays, as the order is important
+ *
+ * @param hostMap - The map to be merged into
+ * @param childMap - The map to be merged from
+ */
+function mergeContractJournalMaps(hostMap: Map<bigint, Map<bigint, Fr[]>>, childMap: Map<bigint, Map<bigint, Fr[]>>) {
+  for (const [key, value] of childMap) {
+    const map1Value = hostMap.get(key);
+    if (!map1Value) {
+      hostMap.set(key, value);
+    } else {
+      mergeStorageJournalMaps(map1Value, value);
+    }
+  }
+}
+
+/**
+ * Merge two storage journalling maps together (for a particular contract).
+ *
+ * @param hostMap - The map to be merge into
+ * @param childMap - The map to be merged from
+ */
+function mergeStorageJournalMaps(hostMap: Map<bigint, Fr[]>, childMap: Map<bigint, Fr[]>) {
+  for (const [key, value] of childMap) {
+    const readArr = hostMap.get(key);
+    if (!readArr) {
+      hostMap.set(key, value);
+    } else {
+      hostMap.set(key, readArr?.concat(...value));
+    }
+  }
+}

package/src/avm/journal/trace_types.ts

@@ -0,0 +1,79 @@
+import { Fr } from '@aztec/foundation/fields';
+
+//export type TracedContractCall = {
+//  callPointer: Fr;
+//  address: Fr;
+//  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 TracedNoteHashCheck = {
+  callPointer: Fr;
+  storageAddress: Fr;
+  leafIndex: Fr;
+  noteHash: Fr;
+  exists: boolean;
+  counter: Fr;
+  endLifetime: Fr;
+};
+//
+//export type TracedNoteHash = {
+//  callPointer: Fr;
+//  storageAddress: Fr;
+//  noteHash: Fr;
+//  counter: Fr;
+//  endLifetime: Fr;
+//};
+
+export type TracedNullifierCheck = {
+  callPointer: Fr;
+  storageAddress: Fr;
+  nullifier: Fr;
+  exists: boolean;
+  counter: 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 TracedL1toL2MessageCheck = {
+  //callPointer: Fr;
+  leafIndex: Fr;
+  msgHash: Fr;
+  exists: boolean;
+  //endLifetime: Fr;
+};
+
+//export type TracedArchiveLeafCheck = {
+//  leafIndex: Fr;
+//  leaf: Fr;
+//};

package/src/avm/opcodes/.eslintrc.cjs

@@ -0,0 +1,8 @@
+const baseConfig = require('@aztec/foundation/eslint');
+module.exports = {
+  ...baseConfig,
+  rules: {
+    ...baseConfig.rules,
+    'require-await': 'off',
+  },
+};

package/src/avm/opcodes/accrued_substate.ts

@@ -0,0 +1,214 @@
+import type { AvmContext } from '../avm_context.js';
+import { Uint8 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { NullifierCollisionError } from '../journal/nullifiers.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+import { StaticCallStorageAlterError } from './storage.js';
+
+export class NoteHashExists extends Instruction {
+  static type: string = 'NOTEHASHEXISTS';
+  static readonly opcode: Opcode = Opcode.NOTEHASHEXISTS;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private noteHashOffset: number,
+    private leafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    // 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 exists = await context.persistableState.checkNoteHashExists(
+      context.environment.storageAddress,
+      noteHash,
+      leafIndex,
+    );
+    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class EmitNoteHash extends Instruction {
+  static type: string = 'EMITNOTEHASH';
+  static readonly opcode: Opcode = Opcode.EMITNOTEHASH;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
+
+  constructor(private indirect: number, private noteHashOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallStorageAlterError();
+    }
+
+    const noteHash = context.machineState.memory.get(this.noteHashOffset).toFr();
+    context.persistableState.writeNoteHash(noteHash);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class NullifierExists extends Instruction {
+  static type: string = 'NULLIFIEREXISTS';
+  static readonly opcode: Opcode = Opcode.NULLIFIEREXISTS;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
+
+  constructor(private indirect: number, private nullifierOffset: number, private existsOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const nullifier = context.machineState.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));
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class EmitNullifier extends Instruction {
+  static type: string = 'EMITNULLIFIER';
+  static readonly opcode: Opcode = Opcode.EMITNULLIFIER;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
+
+  constructor(private indirect: number, private nullifierOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallStorageAlterError();
+    }
+
+    const nullifier = context.machineState.memory.get(this.nullifierOffset).toFr();
+    try {
+      await context.persistableState.writeNullifier(context.environment.storageAddress, nullifier);
+    } catch (e) {
+      if (e instanceof NullifierCollisionError) {
+        // Error is known/expected, raise as InstructionExecutionError that the will lead the simulator to revert this call
+        throw new InstructionExecutionError(
+          `Attempted to emit duplicate nullifier ${nullifier} (storage address: ${context.environment.storageAddress}).`,
+        );
+      } else {
+        throw e;
+      }
+    }
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class L1ToL2MessageExists extends Instruction {
+  static type: string = 'L1TOL2MSGEXISTS';
+  static readonly opcode: Opcode = Opcode.L1TOL2MSGEXISTS;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private msgHashOffset: number,
+    private msgLeafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    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();
+    const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
+    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class EmitUnencryptedLog extends Instruction {
+  static type: string = 'EMITUNENCRYPTEDLOG';
+  static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private eventSelectorOffset: number,
+    private logOffset: number,
+    private logSize: number,
+  ) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallStorageAlterError();
+    }
+
+    const [eventSelectorOffset, logOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.eventSelectorOffset, this.logOffset],
+      context.machineState.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());
+    context.persistableState.writeLog(contractAddress, event, log);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class SendL2ToL1Message extends Instruction {
+  static type: string = 'SENDL2TOL1MSG';
+  static readonly opcode: Opcode = Opcode.SENDL2TOL1MSG;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
+
+  constructor(private indirect: number, private recipientOffset: number, private contentOffset: number) {
+    super();
+  }
+
+  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();
+    context.persistableState.writeL1Message(recipient, content);
+
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/addressing_mode.ts

@@ -0,0 +1,66 @@
+import { strict as assert } from 'assert';
+
+import { TaggedMemory, TypeTag } from '../avm_memory_types.js';
+
+export enum AddressingMode {
+  DIRECT,
+  INDIRECT,
+  INDIRECT_PLUS_CONSTANT, // Not implemented yet.
+}
+
+/** A class to represent the addressing mode of an instruction. */
+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[],
+  ) {
+    assert(modePerOperand.length <= 8, 'At most 8 operands are supported');
+  }
+
+  public static fromWire(wireModes: number): Addressing {
+    // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
+    // The least significant bit represents the zeroth operand, and the most significant bit represents the last operand.
+    const modes = new Array<AddressingMode>(8);
+    for (let i = 0; i < 8; i++) {
+      modes[i] = (wireModes & (1 << i)) === 0 ? AddressingMode.DIRECT : AddressingMode.INDIRECT;
+    }
+    return new Addressing(modes);
+  }
+
+  public toWire(): number {
+    // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
+    // The least significant bit represents the zeroth operand, and the least significant bit represents the last operand.
+    let wire: number = 0;
+    for (let i = 0; i < 8; i++) {
+      if (this.modePerOperand[i] === AddressingMode.INDIRECT) {
+        wire |= 1 << i;
+      }
+    }
+    return wire;
+  }
+
+  /**
+   * 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[] {
+    assert(offsets.length <= this.modePerOperand.length);
+    const resolved = new Array(offsets.length);
+    for (const [i, offset] of offsets.entries()) {
+      switch (this.modePerOperand[i]) {
+        case AddressingMode.INDIRECT:
+          mem.checkTag(TypeTag.UINT32, offset);
+          resolved[i] = Number(mem.get(offset).toBigInt());
+          break;
+        case AddressingMode.DIRECT:
+          resolved[i] = offset;
+          break;
+        default:
+          throw new Error(`Unimplemented addressing mode: ${AddressingMode[this.modePerOperand[i]]}`);
+      }
+    }
+    return resolved;
+  }
+}

package/src/avm/opcodes/arithmetic.ts

@@ -0,0 +1,79 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode } from '../serialization/instruction_serialization.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);
+  }
+
+  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.add(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;
+
+  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.sub(b);
+    context.machineState.memory.set(this.dstOffset, dest);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Mul extends ThreeOperandInstruction {
+  static type: string = 'MUL';
+  static readonly opcode = Opcode.MUL;
+
+  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.mul(b);
+    context.machineState.memory.set(this.dstOffset, dest);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Div extends ThreeOperandInstruction {
+  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();
+  }
+}