@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

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

@@ -1,15 +0,0 @@
-export * from './arithmetic.js';
-export * from './bitwise.js';
-export * from './control_flow.js';
-export * from './contract.js';
-export * from './conversion.js';
-export * from './instruction.js';
-export * from './comparators.js';
-export * from './memory.js';
-export * from './misc.js';
-export * from './storage.js';
-export * from './external_calls.js';
-export * from './environment_getters.js';
-export * from './accrued_substate.js';
-export * from './hashing.js';
-export * from './ec_add.js';

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

@@ -1,136 +0,0 @@
-import type { Bufferable } from '@aztec/foundation/serialize';
-
-import { strict as assert } from 'assert';
-
-import type { AvmContext } from '../avm_context.js';
-import { type Gas, computeAddressingCost, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
-import type { BufferCursor } from '../serialization/buffer_cursor.js';
-import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
-
-type InstructionConstructor = {
-  new (...args: any[]): Instruction;
-};
-
-/**
- * Parent class for all AVM instructions.
- * It's most important aspects are execute and (de)serialize.
- */
-export abstract class Instruction {
-  /**
-   * Consumes gas and executes the instruction.
-   * This is the main entry point for the instruction.
-   * @param context - The AvmContext in which the instruction executes.
-   */
-  public abstract execute(context: AvmContext): Promise<void>;
-
-  /**
-   * Whether the instruction will modify the PC itself.
-   */
-  public handlesPC(): boolean {
-    return false;
-  }
-
-  /**
-   * Generate a string representation of the instruction including
-   * the instruction sub-class name all of its flags and operands.
-   * @returns Thee string representation.
-   */
-  public toString(): string {
-    // Note: we could have this be the actual wire opcode if `bytecode_serialization.ts` were to
-    // pass it into the class' static `Instruction.as(this, wireFormat)` method.
-    let instructionStr = this.constructor.name + ': ';
-    // assumes that all properties are flags or operands
-    for (const prop of Object.getOwnPropertyNames(this) as (keyof Instruction)[]) {
-      instructionStr += `${prop}:${this[prop].toString()}, `;
-    }
-    return instructionStr;
-  }
-
-  // Default deserialization which uses Class.opcode and Class.wireFormat.
-  public static fromBuffer(
-    this: InstructionConstructor & { wireFormat: OperandType[]; as: any },
-    buf: BufferCursor | Buffer,
-  ): Instruction {
-    return this.as(this.wireFormat).fromBuffer(buf);
-  }
-
-  // Default serialization which uses Class.opcode and Class.wireFormat.
-  public toBuffer(): Buffer {
-    const klass = this.constructor as any;
-    assert(klass.opcode !== undefined && klass.opcode !== null);
-    assert(klass.wireFormat !== undefined && klass.wireFormat !== null);
-    return this.as(klass.opcode, klass.wireFormat).toBuffer();
-  }
-
-  /**
-   * Returns a new instruction instance that can be serialized with the given opcode and wire format.
-   * @param opcode The opcode of the instruction.
-   * @param wireFormat The wire format of the instruction.
-   * @returns The new instruction instance.
-   */
-  public as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Bufferable {
-    return Object.defineProperty(this, 'toBuffer', {
-      value: (): Buffer => {
-        return serializeAs(wireFormat, opcode, this);
-      },
-      enumerable: false,
-    });
-  }
-
-  /**
-   * Returns a new instruction class that can be deserialized with the given opcode and wire format.
-   * @param opcode The opcode of the instruction.
-   * @param wireFormat The wire format of the instruction.
-   * @returns The new instruction class.
-   */
-  public static as(this: InstructionConstructor, wireFormat: OperandType[]) {
-    return Object.assign(this, {
-      fromBuffer: (buf: BufferCursor | Buffer): Instruction => {
-        const res = deserialize(buf, wireFormat);
-        const args = res.slice(1); // Remove opcode.
-        return new this(...args);
-      },
-    });
-  }
-
-  /**
-   * Returns the base gas cost for the instruction.
-   * @returns The base gas cost.
-   */
-  protected baseGasCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas {
-    return sumGas(getBaseGasCost(this.opcode), computeAddressingCost(indirectOperandsCount, relativeOperandsCount));
-  }
-
-  /**
-   * Computes the dynamic gas cost for the instruction
-   * @param dynMultiplier - The multiplier for the dynamic gas cost.
-   * @returns The dynamic gas cost.
-   */
-  protected dynamicGasCost(dynMultiplier: number = 0): Gas {
-    return mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
-  }
-
-  /**
-   * Returns the stringified type of the instruction.
-   * Instruction sub-classes should have a static `type` property.
-   */
-  public get type(): string {
-    const type = 'type' in this.constructor && (this.constructor.type as string);
-    assert(!!type, `Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
-    return type;
-  }
-
-  /**
-   * Returns the opcode of the instruction.
-   * Instruction sub-classes should have a static `opcode` property.
-   */
-  public get opcode(): Opcode {
-    const opcode = 'opcode' in this.constructor ? (this.constructor.opcode as Opcode) : undefined;
-    assert(
-      opcode !== undefined,
-      `Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`,
-    );
-    assert(Opcode[opcode] !== undefined, `Invalid opcode ${opcode} for instruction class ${this.constructor.name}.`);
-    return opcode;
-  }
-}

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

@@ -1,36 +0,0 @@
-import { OperandType } from '../serialization/instruction_serialization.js';
-import { Instruction } from './instruction.js';
-
-/** Wire format that informs deserialization for instructions with three operands. */
-export const ThreeOperandWireFormat8 = [
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-];
-export const ThreeOperandWireFormat16 = [
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT16,
-  OperandType.UINT16,
-  OperandType.UINT16,
-];
-
-/**
- * Covers (de)serialization for an instruction with:
- * indirect, inTag, and three operands.
- */
-export abstract class ThreeOperandInstruction extends Instruction {
-  static readonly wireFormat8: OperandType[] = ThreeOperandWireFormat8;
-  static readonly wireFormat16: OperandType[] = ThreeOperandWireFormat16;
-
-  constructor(
-    protected indirect: number,
-    protected aOffset: number,
-    protected bOffset: number,
-    protected dstOffset: number,
-  ) {
-    super();
-  }
-}

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

@@ -1,293 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-
-import { strict as assert } from 'assert';
-
-import type { AvmContext } from '../avm_context.js';
-import { Field, TaggedMemory, TypeTag, Uint32 } from '../avm_memory_types.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class Set extends Instruction {
-  static readonly type: string = 'SET';
-  // Required for gas.
-  static readonly opcode: Opcode = Opcode.SET_8;
-
-  public static readonly wireFormat8: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
-    OperandType.UINT8, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT8, // const (value)
-  ];
-  public static readonly wireFormat16: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT16, // const (value)
-  ];
-  public static readonly wireFormat32: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT32, // const (value)
-  ];
-  public static readonly wireFormat64: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT64, // const (value)
-  ];
-  public static readonly wireFormat128: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT128, // const (value)
-  ];
-  public static readonly wireFormatFF: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.FF, // const (value)
-  ];
-
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private inTag: number,
-    private value: bigint | number,
-  ) {
-    super();
-    assert(this.value >= 0, `Value ${this.value} is negative`);
-    assert(this.value < Fr.MODULUS, `Value ${this.value} is larger than Fr.MODULUS`);
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    // Constructor ensured that this.inTag is a valid tag
-    const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.dstOffset];
-    const [dstOffset] = addressing.resolve(operands, memory);
-    memory.set(dstOffset, res);
-  }
-}
-
-export class Cast extends Instruction {
-  static readonly type: string = 'CAST';
-  static readonly opcode = Opcode.CAST_8;
-
-  static readonly wireFormat8 = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.TAG,
-  ];
-  static readonly wireFormat16 = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.TAG,
-  ];
-
-  constructor(
-    private indirect: number,
-    private srcOffset: number,
-    private dstOffset: number,
-    private dstTag: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.srcOffset, this.dstOffset];
-    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
-
-    const a = memory.get(srcOffset);
-    // Constructor ensured that this.dstTag is a valid tag
-    const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.dstTag);
-
-    memory.set(dstOffset, casted);
-  }
-}
-
-export class Mov extends Instruction {
-  static readonly type: string = 'MOV';
-  // FIXME: This is needed for gas.
-  static readonly opcode: Opcode = Opcode.MOV_8;
-
-  static readonly wireFormat8: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-  ];
-  static readonly wireFormat16: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private indirect: number,
-    private srcOffset: number,
-    private dstOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.srcOffset, this.dstOffset];
-    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
-    const a = memory.get(srcOffset);
-    memory.set(dstOffset, a);
-  }
-}
-
-export class CalldataCopy extends Instruction {
-  static readonly type: string = 'CALLDATACOPY';
-  static readonly opcode: Opcode = Opcode.CALLDATACOPY;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private indirect: number,
-    private copySizeOffset: number,
-    private cdStartOffset: number,
-    private dstOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.copySizeOffset, this.cdStartOffset, this.dstOffset];
-    const [copySizeOffset, cdStartOffset, dstOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTags(TypeTag.UINT32, cdStartOffset, copySizeOffset);
-    const cdStart = memory.get(cdStartOffset).toNumber();
-    const copySize = memory.get(copySizeOffset).toNumber();
-    context.machineState.consumeGas(this.dynamicGasCost(copySize));
-
-    // Values which are out-of-range of the calldata array will be set with Field(0);
-    const slice = context.environment.calldata.slice(cdStart, cdStart + copySize).map(f => new Field(f));
-    // slice has size = MIN(copySize, calldata.length - cdStart) as TS truncates out-of-range portion
-    const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
-
-    memory.setSlice(dstOffset, transformedData);
-  }
-}
-
-export class ReturndataSize extends Instruction {
-  static readonly type: string = 'RETURNDATASIZE';
-  static readonly opcode: Opcode = Opcode.RETURNDATASIZE;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
-
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.dstOffset];
-    const [dstOffset] = addressing.resolve(operands, memory);
-
-    memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
-  }
-}
-
-export class ReturndataCopy extends Instruction {
-  static readonly type: string = 'RETURNDATACOPY';
-  static readonly opcode: Opcode = Opcode.RETURNDATACOPY;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private indirect: number,
-    private copySizeOffset: number,
-    private rdStartOffset: number,
-    private dstOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.copySizeOffset, this.rdStartOffset, this.dstOffset];
-    const [copySizeOffset, rdStartOffset, dstOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTags(TypeTag.UINT32, rdStartOffset, copySizeOffset);
-    const copySize = memory.get(copySizeOffset).toNumber();
-    const rdStart = memory.get(rdStartOffset).toNumber();
-    context.machineState.consumeGas(this.dynamicGasCost(copySize));
-
-    // Values which are out-of-range of the returndata array will be set with Field(0);
-    const slice = context.machineState.nestedReturndata.slice(rdStart, rdStart + copySize).map(f => new Field(f));
-    // slice has size = MIN(copySize, returndata.length - rdStart) as TS truncates out-of-range portion
-    const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
-
-    memory.setSlice(dstOffset, transformedData);
-  }
-}

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

@@ -1,102 +0,0 @@
-import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
-
-import type { AvmContext } from '../avm_context.js';
-import { TypeTag } from '../avm_memory_types.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class DebugLog extends Instruction {
-  static type: string = 'DEBUGLOG';
-  static readonly opcode: Opcode = Opcode.DEBUGLOG;
-  static readonly logger = createLogger('simulator:avm:debug_log');
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8, // Opcode
-    OperandType.UINT8, // Indirect
-    OperandType.UINT16, // level memory address
-    OperandType.UINT16, // message memory address
-    OperandType.UINT16, // fields memory address
-    OperandType.UINT16, // fields size address
-    OperandType.UINT16, // message size
-  ];
-
-  constructor(
-    private indirect: number,
-    private levelOffset: number,
-    private messageOffset: number,
-    private fieldsOffset: number,
-    private fieldsSizeOffset: number,
-    private messageSize: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.levelOffset, this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
-    const [levelOffset, messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
-
-    // DebugLog is a no-op except when doing client-initiated simulation.
-    // Note that we still do address resolution and basic tag-checking (above)
-    // To avoid a special-case in the witness generator and circuit.
-    if (context.environment.clientInitiatedSimulation) {
-      memory.checkTag(TypeTag.UINT8, levelOffset);
-      const levelNumber = memory.get(levelOffset).toNumber();
-      memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
-      const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
-
-      const memoryReads = 1 /* level */ + 1 /* fieldsSize */ + this.messageSize /* message */ + fieldsSize; /* fields */
-      if (
-        context.persistableState.getDebugLogMemoryReads() + memoryReads >
-        context.environment.maxDebugLogMemoryReads
-      ) {
-        // Regular error on purpose: this is not a recoverable error.
-        throw new Error(
-          `Max debug log memory reads exceeded: ${context.persistableState.getDebugLogMemoryReads() + memoryReads} > ${context.environment.maxDebugLogMemoryReads}`,
-        );
-      }
-      context.persistableState.writeDebugLogMemoryReads(memoryReads);
-
-      const rawMessage = memory.getSlice(messageOffset, this.messageSize);
-      const fields = memory.getSlice(fieldsOffset, fieldsSize);
-
-      memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
-      memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
-
-      // Interpret str<N> = [u8; N] to string.
-      const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
-
-      if (!LogLevels[levelNumber]) {
-        // Regular error on purpose: this is not a recoverable error.
-        throw new Error(`Invalid debug log level: ${levelNumber}`);
-      }
-
-      const level = LogLevels[levelNumber];
-
-      context.persistableState.writeDebugLog(
-        context.environment.address,
-        level,
-        messageAsStr,
-        fields.map(field => field.toFr()),
-      );
-
-      // Skips string formatting if the level is disabled.
-      if (DebugLog.logger.isLevelEnabled(level)) {
-        const formattedStr = applyStringFormatting(
-          messageAsStr,
-          fields.map(field => field.toFr()),
-        );
-
-        DebugLog.logger[level](formattedStr);
-      }
-    }
-  }
-}

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

@@ -1,87 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag } from '../avm_memory_types.js';
-import { StaticCallAlterationError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-abstract class BaseStorageInstruction extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  public static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    protected indirect: number,
-    protected aOffset: number,
-    protected bOffset: number,
-  ) {
-    super();
-  }
-}
-
-export class SStore extends BaseStorageInstruction {
-  static readonly type: string = 'SSTORE';
-  static readonly opcode = Opcode.SSTORE;
-
-  constructor(indirect: number, srcOffset: number, slotOffset: number) {
-    super(indirect, srcOffset, slotOffset);
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    if (context.environment.isStaticCall) {
-      throw new StaticCallAlterationError();
-    }
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.aOffset, this.bOffset];
-    const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
-    // We read before tag checking since it's needed for gas cost calculation
-    const slot = memory.get(slotOffset).toFr();
-
-    context.machineState.consumeGas(
-      this.dynamicGasCost(Number(context.persistableState.isStorageCold(context.environment.address, slot))),
-    );
-
-    memory.checkTag(TypeTag.FIELD, slotOffset);
-    memory.checkTag(TypeTag.FIELD, srcOffset);
-
-    const value = memory.get(srcOffset).toFr();
-    await context.persistableState.writeStorage(context.environment.address, slot, value);
-  }
-}
-
-export class SLoad extends BaseStorageInstruction {
-  static readonly type: string = 'SLOAD';
-  static readonly opcode = Opcode.SLOAD;
-
-  constructor(indirect: number, slotOffset: number, dstOffset: number) {
-    super(indirect, slotOffset, dstOffset);
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.aOffset, this.bOffset];
-    const [slotOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.FIELD, slotOffset);
-
-    const slot = memory.get(slotOffset).toFr();
-    const value = await context.persistableState.readStorage(context.environment.address, slot);
-    memory.set(dstOffset, new Field(value));
-  }
-}