@aztec/simulator 0.0.1-commit.4d79d1f2d → 0.0.1-commit.4d9804df

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

@@ -1,113 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { getBitwiseDynamicGasMultiplier } from '../avm_gas.js';
-import { type IntegralValue, TaggedMemory, type TaggedMemoryInterface, 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';
-import { ThreeOperandInstruction } from './instruction_impl.js';
-
-abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
-    this.checkTags(memory, aOffset, bOffset);
-
-    const multiplier = this.getDynamicMultiplier(memory.getTag(aOffset));
-    context.machineState.consumeGas(this.dynamicGasCost(multiplier));
-
-    const a = memory.getAs<IntegralValue>(aOffset);
-    const b = memory.getAs<IntegralValue>(bOffset);
-
-    const res = this.compute(a, b);
-    memory.set(dstOffset, res);
-  }
-
-  protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
-  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
-    memory.checkTagsAreSame(aOffset, bOffset);
-  }
-
-  protected getDynamicMultiplier(_lhsTag: TypeTag): number {
-    return 0;
-  }
-}
-
-export class And extends ThreeOperandBitwiseInstruction {
-  static readonly type: string = 'AND';
-  static readonly opcode = Opcode.AND_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.and(b);
-  }
-
-  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
-    return getBitwiseDynamicGasMultiplier(lhsTag);
-  }
-}
-
-export class Or extends ThreeOperandBitwiseInstruction {
-  static readonly type: string = 'OR';
-  static readonly opcode = Opcode.OR_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.or(b);
-  }
-
-  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
-    return getBitwiseDynamicGasMultiplier(lhsTag);
-  }
-}
-
-export class Xor extends ThreeOperandBitwiseInstruction {
-  static readonly type: string = 'XOR';
-  static readonly opcode = Opcode.XOR_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.xor(b);
-  }
-
-  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
-    return getBitwiseDynamicGasMultiplier(lhsTag);
-  }
-}
-
-export class Not extends Instruction {
-  static readonly type: string = 'NOT';
-  static readonly opcode = Opcode.NOT_8;
-
-  static readonly wireFormat8 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT8, OperandType.UINT8];
-  static readonly wireFormat16 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
-
-  constructor(
-    private addressingMode: 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.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.srcOffset, this.dstOffset];
-    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
-    TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
-    const value = memory.getAs<IntegralValue>(srcOffset);
-
-    const res = value.not();
-    memory.set(dstOffset, res);
-  }
-}

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

@@ -1,55 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { type MemoryValue, Uint1 } from '../avm_memory_types.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { ThreeOperandInstruction } from './instruction_impl.js';
-
-abstract class ComparatorInstruction extends ThreeOperandInstruction {
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTagsAreSame(aOffset, bOffset); // Brillig semantic enforces that tags match.
-
-    const a = memory.get(aOffset);
-    const b = memory.get(bOffset);
-
-    const dest = new Uint1(this.compare(a, b) ? 1 : 0);
-    memory.set(dstOffset, dest);
-  }
-
-  protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;
-}
-
-export class Eq extends ComparatorInstruction {
-  static readonly type: string = 'EQ';
-  static readonly opcode = Opcode.EQ_8; // FIXME: needed for gas.
-
-  protected compare(a: MemoryValue, b: MemoryValue): boolean {
-    return a.equals(b);
-  }
-}
-
-export class Lt extends ComparatorInstruction {
-  static readonly type: string = 'LT';
-  static readonly opcode = Opcode.LT_8; // FIXME: needed for gas.
-
-  protected compare(a: MemoryValue, b: MemoryValue): boolean {
-    return a.lt(b);
-  }
-}
-
-export class Lte extends ComparatorInstruction {
-  static readonly type: string = 'LTE';
-  static readonly opcode = Opcode.LTE_8; // FIXME: needed for gas.
-
-  protected compare(a: MemoryValue, b: MemoryValue): boolean {
-    return a.lt(b) || a.equals(b);
-  }
-}

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

@@ -1,72 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export enum ContractInstanceMember {
-  DEPLOYER,
-  CLASS_ID,
-  INIT_HASH,
-}
-
-export class GetContractInstance extends Instruction {
-  static readonly type: string = 'GETCONTRACTINSTANCE';
-  static readonly opcode: Opcode = Opcode.GETCONTRACTINSTANCE;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode bits
-    OperandType.UINT16, // addressOffset
-    OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // member enum (immediate)
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private addressOffset: number,
-    private dstOffset: number,
-    private memberEnum: number,
-  ) {
-    super();
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    if (!(this.memberEnum in ContractInstanceMember)) {
-      throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
-    }
-
-    const operands = [this.addressOffset, this.dstOffset];
-    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.FIELD, addressOffset);
-
-    const address = memory.get(addressOffset).toAztecAddress();
-    const instance = await context.persistableState.getContractInstance(address);
-    const exists = instance !== undefined;
-
-    let memberValue = new Field(0);
-    if (exists) {
-      switch (this.memberEnum as ContractInstanceMember) {
-        case ContractInstanceMember.DEPLOYER:
-          memberValue = new Field(instance.deployer.toField());
-          break;
-        case ContractInstanceMember.CLASS_ID:
-          memberValue = new Field(instance.currentContractClassId.toField());
-          break;
-        case ContractInstanceMember.INIT_HASH:
-          memberValue = new Field(instance.initializationHash);
-          break;
-      }
-    }
-
-    memory.setSlice(dstOffset, [new Uint1(exists ? 1 : 0), memberValue]);
-  }
-}

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

@@ -1,123 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { TypeTag, type Uint1 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class Jump extends Instruction {
-  static type: string = 'JUMP';
-  static readonly opcode: Opcode = Opcode.JUMP_32;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
-
-  constructor(private jumpOffset: number) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.baseGasCost(0, 0));
-
-    context.machineState.pc = this.jumpOffset;
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class JumpI extends Instruction {
-  static type: string = 'JUMPI';
-  static readonly opcode: Opcode = Opcode.JUMPI_32;
-
-  // Instruction wire format with opcode.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT32,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private condOffset: number,
-    private loc: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.condOffset];
-    const [resolvedCondOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTag(TypeTag.UINT1, resolvedCondOffset);
-    const condition = memory.getAs<Uint1>(resolvedCondOffset);
-
-    if (condition.toNumber() == 0) {
-      context.machineState.pc = context.machineState.nextPc;
-    } else {
-      context.machineState.pc = this.loc;
-    }
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class InternalCall extends Instruction {
-  static readonly type: string = 'INTERNALCALL';
-  static readonly opcode: Opcode = Opcode.INTERNALCALL;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
-
-  constructor(private loc: number) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.baseGasCost(0, 0));
-
-    context.machineState.internalCallStack.push({
-      callPc: context.machineState.pc,
-      returnPc: context.machineState.nextPc,
-    });
-    context.machineState.pc = this.loc;
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class InternalReturn extends Instruction {
-  static readonly type: string = 'INTERNALRETURN';
-  static readonly opcode: Opcode = Opcode.INTERNALRETURN;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8];
-
-  constructor() {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.baseGasCost(0, 0));
-
-    const stackEntry = context.machineState.internalCallStack.pop();
-    if (stackEntry === undefined) {
-      throw new InstructionExecutionError('Internal call stack empty!');
-    }
-    context.machineState.pc = stackEntry.returnPc;
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}

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

@@ -1,104 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
-import { InvalidToRadixInputsError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class ToRadixBE extends Instruction {
-  static type: string = 'TORADIXBE';
-  static readonly opcode: Opcode = Opcode.TORADIXBE;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8, // Opcode
-    OperandType.UINT16, // addressing_mode
-    OperandType.UINT16, // src memory address
-    OperandType.UINT16, // radix memory address
-    OperandType.UINT16, // number of limbs address
-    OperandType.UINT16, // output is in "bits" mode memory address (boolean/Uint1 is stored)
-    OperandType.UINT16, // dst memory address
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private srcOffset: number,
-    private radixOffset: number,
-    private numLimbsOffset: number,
-    private outputBitsOffset: number,
-    private dstOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.srcOffset, this.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
-    const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
-
-    // The radix gadget only takes in a Field
-    memory.checkTag(TypeTag.FIELD, srcOffset);
-    memory.checkTag(TypeTag.UINT32, radixOffset);
-    memory.checkTag(TypeTag.UINT32, numLimbsOffset);
-    memory.checkTag(TypeTag.UINT1, outputBitsOffset);
-
-    const numLimbs = memory.get(numLimbsOffset).toNumber();
-    const radix: bigint = memory.get(radixOffset).toBigInt();
-    context.machineState.consumeGas(
-      this.dynamicGasCost(Math.max(numLimbs, radix > 256n ? 32 : MODULUS_LIMBS_PER_RADIX[Number(radix)])),
-    );
-    const outputBits = memory.get(outputBitsOffset).toNumber();
-
-    let value: bigint = memory.get(srcOffset).toBigInt();
-
-    if (radix < 2 || radix > 256) {
-      throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
-    }
-
-    if (numLimbs < 1 && value != BigInt(0n)) {
-      throw new InvalidToRadixInputsError(
-        `ToRadixBE instruction's input value is not zero (was ${value}) but numLimbs zero.`,
-      );
-    }
-
-    if (outputBits != 0 && radix != BigInt(2n)) {
-      throw new InvalidToRadixInputsError(`Radix ${radix} is not equal to 2 and bit mode is activated.`);
-    }
-
-    const radixBN: bigint = BigInt(radix);
-    const limbArray = new Array(numLimbs);
-
-    for (let i = numLimbs - 1; i >= 0; i--) {
-      const limb = value % radixBN;
-      limbArray[i] = limb;
-      value /= radixBN;
-    }
-
-    if (value !== 0n) {
-      throw new InvalidToRadixInputsError(`Field failed to decompose in ${numLimbs} limbs.`);
-    }
-
-    const outputType = outputBits != 0 ? Uint1 : Uint8;
-    const res = limbArray.map(byte => new outputType(byte));
-    memory.setSlice(dstOffset, res);
-  }
-}
-
-// First two are for radix = 0 and 1, which are invalid, so we have 0 limbs for those cases.
-export const MODULUS_LIMBS_PER_RADIX: number[] = [
-  0, 0, 254, 161, 127, 110, 99, 91, 85, 81, 77, 74, 71, 69, 67, 65, 64, 63, 61, 60, 59, 58, 57, 57, 56, 55, 54, 54, 53,
-  53, 52, 52, 51, 51, 50, 50, 50, 49, 49, 48, 48, 48, 48, 47, 47, 47, 46, 46, 46, 46, 45, 45, 45, 45, 45, 44, 44, 44,
-  44, 44, 43, 43, 43, 43, 43, 43, 42, 42, 42, 42, 42, 42, 42, 41, 41, 41, 41, 41, 41, 41, 41, 41, 40, 40, 40, 40, 40,
-  40, 40, 40, 40, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
-  37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
-  36, 36, 36, 36, 36, 36, 36, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
-  35, 35, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
-  34, 34, 34, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
-  33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
-];

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

@@ -1,105 +0,0 @@
-import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
-import { Point } from '@aztec/foundation/curves/grumpkin';
-
-import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { EcAddPointNotOnCurveError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class EcAdd extends Instruction {
-  static type: string = 'ECADD';
-  static readonly opcode = Opcode.ECADD;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8, // reserved
-    OperandType.UINT16, // indirect
-    OperandType.UINT16, // p1X
-    OperandType.UINT16, // p1Y
-    OperandType.UINT16, // p1IsInfinite
-    OperandType.UINT16, // p2X
-    OperandType.UINT16, // p2Y
-    OperandType.UINT16, // p2IsInfinite
-    OperandType.UINT16, // dst
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private p1XOffset: number,
-    private p1YOffset: number,
-    private p1IsInfiniteOffset: number,
-    private p2XOffset: number,
-    private p2YOffset: number,
-    private p2IsInfiniteOffset: number,
-    private dstOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [
-      this.p1XOffset,
-      this.p1YOffset,
-      this.p1IsInfiniteOffset,
-      this.p2XOffset,
-      this.p2YOffset,
-      this.p2IsInfiniteOffset,
-      this.dstOffset,
-    ];
-    const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
-      addressing.resolve(operands, memory);
-
-    memory.checkTags(TypeTag.FIELD, p1XOffset, p1YOffset, p2XOffset, p2YOffset);
-    memory.checkTags(TypeTag.UINT1, p1IsInfiniteOffset, p2IsInfiniteOffset);
-
-    const p1X = memory.get(p1XOffset);
-    const p1Y = memory.get(p1YOffset);
-    const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
-    const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
-    if (!p1.isOnGrumpkin()) {
-      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
-    }
-
-    const p2X = memory.get(p2XOffset);
-    const p2Y = memory.get(p2YOffset);
-    // unused. Point doesn't store this information
-    const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
-    const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
-    if (!p2.isOnGrumpkin()) {
-      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
-    }
-
-    let dest;
-    if (p1IsInfinite && p2IsInfinite) {
-      dest = Point.ZERO;
-    } else if (p1IsInfinite) {
-      dest = p2;
-    } else if (p2IsInfinite) {
-      dest = p1;
-    } else {
-      // TS<>BB ecc add communication is broken for points that add up to infinity.
-      // However, here we know that both points are on the curve, and that none is infinity
-      // so we can check for the case where you add p + (-p) = infinity.
-      if (p1.x.equals(p2.x) && !p1.y.equals(p2.y)) {
-        dest = Point.ZERO;
-      } else {
-        dest = await Grumpkin.add(p1, p2);
-      }
-    }
-
-    // Important to use setSlice() and not set() in the two following statements as
-    // this checks that the offsets lie within memory range.
-    memory.setSlice(dstOffset, [new Field(dest.x), new Field(dest.y)]);
-    // Check representation of infinity for grumpkin
-    memory.setSlice(dstOffset + 2, [new Uint1(dest.equals(Point.ZERO) ? 1 : 0)]);
-  }
-}

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

@@ -1,87 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { Field, Uint1, Uint32, Uint64, Uint128 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export enum EnvironmentVariable {
-  ADDRESS,
-  SENDER,
-  TRANSACTIONFEE,
-  CHAINID,
-  VERSION,
-  BLOCKNUMBER,
-  TIMESTAMP,
-  MINFEEPERL2GAS,
-  MINFEEPERDAGAS,
-  ISSTATICCALL,
-  L2GASLEFT,
-  DAGASLEFT,
-}
-
-function getValue(varEnum: EnvironmentVariable, ctx: AvmContext) {
-  switch (varEnum) {
-    case EnvironmentVariable.ADDRESS:
-      return new Field(ctx.environment.address.toField());
-    case EnvironmentVariable.SENDER:
-      return new Field(ctx.environment.sender.toField());
-    case EnvironmentVariable.TRANSACTIONFEE:
-      return new Field(ctx.environment.transactionFee);
-    case EnvironmentVariable.CHAINID:
-      return new Field(ctx.environment.globals.chainId);
-    case EnvironmentVariable.VERSION:
-      return new Field(ctx.environment.globals.version);
-    case EnvironmentVariable.BLOCKNUMBER:
-      return new Uint32(ctx.environment.globals.blockNumber);
-    case EnvironmentVariable.TIMESTAMP:
-      return new Uint64(ctx.environment.globals.timestamp);
-    case EnvironmentVariable.MINFEEPERL2GAS:
-      return new Uint128(ctx.environment.globals.gasFees.feePerL2Gas);
-    case EnvironmentVariable.MINFEEPERDAGAS:
-      return new Uint128(ctx.environment.globals.gasFees.feePerDaGas);
-    case EnvironmentVariable.ISSTATICCALL:
-      return new Uint1(ctx.environment.isStaticCall ? 1 : 0);
-    case EnvironmentVariable.L2GASLEFT:
-      return new Uint32(ctx.machineState.l2GasLeft);
-    case EnvironmentVariable.DAGASLEFT:
-      return new Uint32(ctx.machineState.daGasLeft);
-    default:
-      throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${varEnum}`);
-  }
-}
-
-export class GetEnvVar extends Instruction {
-  public static readonly type: string = 'GETENVVAR';
-  public static readonly opcode: Opcode = Opcode.GETENVVAR_16;
-  static readonly wireFormat16: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode
-    OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // variable enum (immediate)
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private dstOffset: number,
-    private varEnum: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.dstOffset];
-    const [dstOffset] = addressing.resolve(operands, memory);
-
-    const value = getValue(this.varEnum as EnvironmentVariable, context);
-
-    memory.set(dstOffset, value);
-  }
-}