@aztec/simulator 0.0.0-test.0

package/src/public/avm/journal/nullifiers.ts

@@ -0,0 +1,109 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+import type { WorldStateDB } from '../../public_db_sources.js';
+
+/**
+ * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
+ * Maintains a siloed nullifier cache, and ensures that existence checks fall back to the correct source.
+ * When a contract call completes, its cached nullifier set can be merged into its parent's.
+ */
+export class NullifierManager {
+  constructor(
+    /** Reference to node storage. Checked on parent cache-miss. */
+    private readonly hostNullifiers: WorldStateDB,
+    /** Cache of siloed nullifiers. */
+    private cache: Set<bigint> = new Set(),
+    /** Parent nullifier manager to fall back on */
+    private readonly parent?: NullifierManager,
+  ) {}
+
+  /**
+   * Create a new nullifiers manager forked from this one
+   */
+  public fork() {
+    return new NullifierManager(this.hostNullifiers, new Set(), this);
+  }
+
+  /**
+   * Get a nullifier's existence in this' cache or parent's (recursively).
+   * DOES NOT CHECK HOST STORAGE!
+   * @param siloedNullifier - the nullifier to check for
+   * @returns exists: whether the nullifier exists in cache here or in parent's
+   */
+  private checkExistsHereOrParent(siloedNullifier: Fr): boolean {
+    // First check this cache
+    let existsAsPending = this.cache.has(siloedNullifier.toBigInt());
+    // Then try parent's nullifier cache
+    if (!existsAsPending && this.parent) {
+      // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
+      existsAsPending = this.parent.checkExistsHereOrParent(siloedNullifier);
+    }
+    return existsAsPending;
+  }
+
+  /**
+   * Get a nullifier's existence status.
+   * 1. Check cache.
+   * 2. Check parent cache.
+   * 3. Fall back to the host state.
+   * 4. Not found! Nullifier does not exist.
+   *
+   * @param siloedNullifier - the nullifier to check for
+   * @returns exists: whether the nullifier exists at all,
+   *          cacheHit: whether the nullifier was found in a cache,
+   */
+  public async checkExists(siloedNullifier: Fr): Promise<{ exists: boolean; cacheHit: boolean }> {
+    // Check this cache and parent's (recursively)
+    const cacheHit = this.checkExistsHereOrParent(siloedNullifier);
+    let existsInTree = false;
+    if (!cacheHit) {
+      // Finally try the host's Aztec state (a trip to the database)
+      //const leafOrLowLeafIndex = await this.hostNullifiers.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, siloedNullifier.toBigInt());
+      //assert(
+      //  leafOrLowLeafIndex !== undefined,
+      //  `${MerkleTreeId[MerkleTreeId.NULLIFIER_TREE]} low leaf index should always be found (even if target leaf does not exist)`,
+      //);
+      //existsInTree = leafOrLowLeafIndex.alreadyPresent;
+      const leafIndex = await this.hostNullifiers.getNullifierIndex(siloedNullifier);
+      existsInTree = leafIndex !== undefined;
+    }
+    const exists = cacheHit || existsInTree;
+    return Promise.resolve({ exists, cacheHit });
+  }
+
+  /**
+   * Stage a new nullifier (append it to the cache).
+   *
+   * @param siloedNullifier - the nullifier to stage
+   */
+  public async append(siloedNullifier: Fr) {
+    const { exists } = await this.checkExists(siloedNullifier);
+    if (exists) {
+      throw new NullifierCollisionError(`Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`);
+    }
+    this.cache.add(siloedNullifier.toBigInt());
+  }
+
+  /**
+   * Merges another nullifier cache into this one.
+   *
+   * @param incomingNullifiers - the incoming cached nullifiers to merge into this instance's
+   */
+  public acceptAndMerge(incomingNullifiers: NullifierManager) {
+    for (const incomingNullifier of incomingNullifiers.cache) {
+      if (this.cache.has(incomingNullifier)) {
+        throw new NullifierCollisionError(
+          `Failed to merge in fork's cached nullifiers. Siloed nullifier ${incomingNullifier} already exists in parent cache.`,
+        );
+      }
+    }
+    this.cache = new Set([...this.cache, ...incomingNullifiers.cache]);
+  }
+}
+
+export class NullifierCollisionError extends Error {
+  constructor(message: string, ...rest: any[]) {
+    super(message, ...rest);
+    this.name = 'NullifierCollisionError';
+  }
+}

package/src/public/avm/journal/public_storage.ts

@@ -0,0 +1,174 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { PublicStateDB } from '../../../common/db_interfaces.js';
+
+type PublicStorageReadResult = {
+  value: Fr;
+  cached: boolean;
+};
+
+/**
+ * A class to manage public storage reads and writes during a contract call's AVM simulation.
+ * Maintains a storage write cache, and ensures that reads fall back to the correct source.
+ * When a contract call completes, its storage cache can be merged into its parent's.
+ */
+export class PublicStorage {
+  /** Cached storage writes. */
+  private readonly cache: PublicStorageCache;
+
+  constructor(
+    /** Reference to node storage. Checked on parent cache-miss. */
+    private readonly hostPublicStorage: PublicStateDB,
+    /** Parent's storage. Checked on this' cache-miss. */
+    private readonly parent?: PublicStorage,
+  ) {
+    this.cache = new PublicStorageCache();
+  }
+
+  /**
+   * Create a new public storage manager forked from this one
+   */
+  public fork() {
+    return new PublicStorage(this.hostPublicStorage, this);
+  }
+
+  /**
+   * Read a storage value from this' cache or parent's (recursively).
+   * DOES NOT CHECK HOST STORAGE!
+   *
+   * @param contractAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns value: the latest value written according to this cache or the parent's. undefined on cache miss.
+   */
+  public readHereOrParent(contractAddress: AztecAddress, slot: Fr): Fr | undefined {
+    // First try check this storage cache
+    let value = this.cache.read(contractAddress, slot);
+    // Then try parent's storage cache
+    if (!value && this.parent) {
+      // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
+      value = this.parent.readHereOrParent(contractAddress, slot);
+    }
+    return value;
+  }
+
+  /**
+   * Read a value from storage.
+   * 1. Check cache.
+   * 2. Check parent cache.
+   * 3. Fall back to the host state.
+   * 4. Not found! Value has never been written to before. Flag it as non-existent and return value zero.
+   *
+   * @param contractAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns exists: whether the slot has EVER been written to before, value: the latest value written to slot, or 0 if never written to before
+   */
+  public async read(contractAddress: AztecAddress, slot: Fr): Promise<PublicStorageReadResult> {
+    let cached = false;
+    // Check this cache and parent's (recursively)
+    let value = this.readHereOrParent(contractAddress, slot);
+    // Finally try the host's Aztec state (a trip to the database)
+    if (!value) {
+      // This functions returns Fr.ZERO if it has never been written to before
+      // we explicity coalesce to Fr.ZERO in case we have some implementations that cause this to return undefined
+      value = (await this.hostPublicStorage.storageRead(contractAddress, slot)) ?? Fr.ZERO;
+      // TODO(dbanks12): if value retrieved from host storage, we can cache it here
+      // any future reads to the same slot can read from cache instead of more expensive
+      // DB access
+    } else {
+      cached = true;
+    }
+    // if value is Fr.ZERO here, it that means this slot has never been written to!
+    return Promise.resolve({ value, cached });
+  }
+
+  /**
+   * Stage a storage write.
+   *
+   * @param contractAddress - the address of the contract whose storage is being written to
+   * @param slot - the slot in the contract's storage being written to
+   * @param value - the value being written to the slot
+   */
+  public write(contractAddress: AztecAddress, slot: Fr, value: Fr) {
+    this.cache.write(contractAddress, slot, value);
+  }
+
+  /**
+   * Merges another PublicStorage's cache (pending writes) into this one.
+   *
+   * @param incomingPublicStorage - the incoming public storage to merge into this instance's
+   */
+  public acceptAndMerge(incomingPublicStorage: PublicStorage) {
+    this.cache.acceptAndMerge(incomingPublicStorage.cache);
+  }
+}
+
+/**
+ * A class to cache writes to public storage during a contract call's AVM simulation.
+ * "Writes" update a map, "reads" check that map or return undefined.
+ * An instance of this class can merge another instance's staged writes into its own.
+ */
+class PublicStorageCache {
+  /**
+   * Map for staging storage writes.
+   * One inner-map per contract storage address,
+   * mapping storage slot to latest staged write value.
+   */
+  private cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
+
+  /**
+   * Read a staged value from storage, if it has been previously written to.
+   *
+   * @param contractAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns the latest value written to slot, or undefined if no value has been written
+   */
+  public read(contractAddress: AztecAddress, slot: Fr): Fr | undefined {
+    return this.cachePerContract.get(contractAddress.toBigInt())?.get(slot.toBigInt());
+  }
+
+  /**
+   * Stage a storage write.
+   *
+   * @param contractAddress - the address of the contract whose storage is being written to
+   * @param slot - the slot in the contract's storage being written to
+   * @param value - the value being written to the slot
+   */
+  public write(contractAddress: AztecAddress, slot: Fr, value: Fr) {
+    let cacheAtContract = this.cachePerContract.get(contractAddress.toBigInt());
+    if (!cacheAtContract) {
+      // If this contract's storage has no staged modifications, create a new inner map to store them
+      cacheAtContract = new Map();
+      this.cachePerContract.set(contractAddress.toBigInt(), cacheAtContract);
+    }
+    cacheAtContract.set(slot.toBigInt(), value);
+  }
+
+  /**
+   * Merges another cache's staged writes into this instance's cache.
+   *
+   * Staged modifications in "incoming" take precedence over those
+   * present in "this" as they are assumed to occur after this' writes.
+   *
+   * In practice, "this" is a parent call's storage cache, and "incoming" is a nested call's.
+   *
+   * @param incomingStorageCache - the incoming storage write cache to merge into this instance's
+   */
+  public acceptAndMerge(incomingStorageCache: PublicStorageCache) {
+    // Iterate over all incoming contracts with staged writes.
+    for (const [incomingAddress, incomingCacheAtContract] of incomingStorageCache.cachePerContract) {
+      const thisCacheAtContract = this.cachePerContract.get(incomingAddress);
+      if (!thisCacheAtContract) {
+        // The contract has no storage writes staged here
+        // so just accept the incoming cache as-is for this contract.
+        this.cachePerContract.set(incomingAddress, incomingCacheAtContract);
+      } else {
+        // "Incoming" and "this" both have staged writes for this contract.
+        // Merge in incoming staged writes, giving them precedence over this'.
+        for (const [slot, value] of incomingCacheAtContract) {
+          thisCacheAtContract.set(slot, value);
+        }
+      }
+    }
+  }
+}

package/src/public/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/public/avm/opcodes/accrued_substate.ts

@@ -0,0 +1,253 @@
+import type { AvmContext } from '../avm_context.js';
+import { TypeTag, Uint1 } from '../avm_memory_types.js';
+import { InstructionExecutionError, StaticCallAlterationError } 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';
+
+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.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(
+    private indirect: number,
+    private noteHashOffset: number,
+    private leafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+    const operands = [this.noteHashOffset, this.leafIndexOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTags(TypeTag.FIELD, noteHashOffset, leafIndexOffset);
+
+    // Note that this instruction accepts any type in memory, and converts to Field.
+    const noteHash = memory.get(noteHashOffset).toFr();
+    const leafIndex = memory.get(leafIndexOffset).toFr();
+
+    const exists = await context.persistableState.checkNoteHashExists(context.environment.address, noteHash, leafIndex);
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
+  }
+}
+
+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.UINT16];
+
+  constructor(private indirect: number, private noteHashOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.noteHashOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [noteHashOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, noteHashOffset);
+
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const noteHash = memory.get(noteHashOffset).toFr();
+    await context.persistableState.writeNoteHash(context.environment.address, noteHash);
+  }
+}
+
+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.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(
+    private indirect: number,
+    private nullifierOffset: number,
+    private addressOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [nullifierOffset, addressOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
+
+    const nullifier = memory.get(nullifierOffset).toFr();
+    const address = memory.get(addressOffset).toAztecAddress();
+    const exists = await context.persistableState.checkNullifierExists(address, nullifier);
+
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
+  }
+}
+
+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.UINT16];
+
+  constructor(private indirect: number, private nullifierOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.nullifierOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [nullifierOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, nullifierOffset);
+
+    const nullifier = memory.get(nullifierOffset).toFr();
+    try {
+      await context.persistableState.writeNullifier(context.environment.address, 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} (contract address: ${context.environment.address}).`,
+        );
+      } else {
+        throw e;
+      }
+    }
+  }
+}
+
+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.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(
+    private indirect: number,
+    private msgHashOffset: number,
+    private msgLeafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTags(TypeTag.FIELD, msgHashOffset, msgLeafIndexOffset);
+
+    const msgHash = memory.get(msgHashOffset).toFr();
+    const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
+    const exists = await context.persistableState.checkL1ToL2MessageExists(
+      context.environment.address,
+      msgHash,
+      msgLeafIndex,
+    );
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
+  }
+}
+
+export class EmitUnencryptedLog extends Instruction {
+  // TODO(#11124): rename unencrypted -> public
+  static type: string = 'EMITUNENCRYPTEDLOG';
+  static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
+
+  constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const memory = context.machineState.memory;
+
+    const operands = [this.logOffset, this.logSizeOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [logOffset, logSizeOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.UINT32, logSizeOffset);
+    const logSize = memory.get(logSizeOffset).toNumber();
+    memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
+
+    const contractAddress = context.environment.address;
+
+    context.machineState.consumeGas(this.gasCost(logSize));
+    const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
+    context.persistableState.writePublicLog(contractAddress, log);
+  }
+}
+
+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.UINT16, OperandType.UINT16];
+
+  constructor(private indirect: number, private recipientOffset: number, private contentOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.recipientOffset, this.contentOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
+    memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
+
+    const recipient = memory.get(recipientOffset).toFr();
+    const content = memory.get(contentOffset).toFr();
+    context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
+  }
+}

package/src/public/avm/opcodes/addressing_mode.ts

@@ -0,0 +1,87 @@
+import { strict as assert } from 'assert';
+
+import { TaggedMemory, type TaggedMemoryInterface } from '../avm_memory_types.js';
+import { RelativeAddressOutOfRangeError } from '../errors.js';
+
+export enum AddressingMode {
+  DIRECT = 0,
+  INDIRECT = 1,
+  RELATIVE = 2,
+  INDIRECT_RELATIVE = 3,
+}
+
+/** 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[],
+  ) {}
+
+  // TODO(facundo): 8 for backwards compatibility.
+  public static fromWire(wireModes: number, numOperands: number = 8): 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>(numOperands);
+    for (let i = 0; i < numOperands; i++) {
+      modes[i] =
+        (((wireModes >> i) & 1) * AddressingMode.INDIRECT) |
+        (((wireModes >> (i + numOperands)) & 1) * AddressingMode.RELATIVE);
+    }
+    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 < this.modePerOperand.length; i++) {
+      if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
+        wire |= 1 << i;
+      }
+      if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
+        wire |= 1 << (this.modePerOperand.length + i);
+      }
+    }
+    return wire;
+  }
+
+  /** Returns how many operands use the given addressing mode. */
+  public count(mode: AddressingMode): number {
+    return this.modePerOperand.filter(m => (m & mode) !== 0).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: TaggedMemoryInterface): number[] {
+    assert(offsets.length <= this.modePerOperand.length);
+    const resolved = new Array(offsets.length);
+
+    let didRelativeOnce = false;
+    let baseAddr = 0;
+
+    for (const [i, offset] of offsets.entries()) {
+      const mode = this.modePerOperand[i];
+      resolved[i] = offset;
+      if (mode & AddressingMode.RELATIVE) {
+        if (!didRelativeOnce) {
+          mem.checkIsValidMemoryOffsetTag(0);
+          baseAddr = Number(mem.get(0).toBigInt());
+          didRelativeOnce = true;
+        }
+        resolved[i] += baseAddr;
+        if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
+          throw new RelativeAddressOutOfRangeError(baseAddr, offset);
+        }
+      }
+      if (mode & AddressingMode.INDIRECT) {
+        mem.checkIsValidMemoryOffsetTag(resolved[i]);
+        resolved[i] = Number(mem.get(resolved[i]).toBigInt());
+      }
+    }
+    return resolved;
+  }
+}