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

package/src/public/avm/fixtures/initializers.ts

@@ -1,103 +0,0 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { GasFees } from '@aztec/stdlib/gas';
-import { GlobalVariables } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
-
-import { mock } from 'jest-mock-extended';
-
-import type { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
-import type { PublicSideEffectTraceInterface } from '../../side_effect_trace_interface.js';
-import { NullifierManager } from '../../state_manager/nullifiers.js';
-import { PublicStorage } from '../../state_manager/public_storage.js';
-import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
-import { AvmContext } from '../avm_context.js';
-import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { AvmMachineState } from '../avm_machine_state.js';
-import { AvmSimulator } from '../avm_simulator.js';
-import { CallDataArray } from '../calldata.js';
-import { DEFAULT_TIMESTAMP } from './utils.js';
-
-/**
- * Create a new AVM context with default values.
- */
-export function initContext(overrides?: {
-  persistableState?: PublicPersistableStateManager;
-  env?: AvmExecutionEnvironment;
-  machineState?: AvmMachineState;
-}): AvmContext {
-  const ctx = new AvmContext(
-    overrides?.persistableState || initPersistableStateManager(),
-    overrides?.env || initExecutionEnvironment(),
-    overrides?.machineState || initMachineState(),
-  );
-  ctx.provideSimulator = AvmSimulator.build;
-  return ctx;
-}
-
-/** Creates an empty state manager with mocked host storage. */
-export function initPersistableStateManager(overrides?: {
-  treesDB?: PublicTreesDB;
-  contractsDB?: PublicContractsDB;
-  trace?: PublicSideEffectTraceInterface;
-  publicStorage?: PublicStorage;
-  nullifiers?: NullifierManager;
-  firstNullifier?: Fr;
-  timestamp?: UInt64;
-}): PublicPersistableStateManager {
-  const treesDB = overrides?.treesDB || mock<PublicTreesDB>();
-  return new PublicPersistableStateManager(
-    treesDB,
-    overrides?.contractsDB || mock<PublicContractsDB>(),
-    overrides?.trace || mock<PublicSideEffectTraceInterface>(),
-    overrides?.firstNullifier || new Fr(27),
-    overrides?.timestamp || DEFAULT_TIMESTAMP,
-    /*doMerkleOperations=*/ false,
-  );
-}
-
-/**
- * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
- */
-export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnvironment>): AvmExecutionEnvironment {
-  return new AvmExecutionEnvironment(
-    overrides?.address ?? AztecAddress.zero(),
-    overrides?.sender ?? AztecAddress.zero(),
-    overrides?.contractCallDepth ?? Fr.zero(),
-    overrides?.transactionFee ?? Fr.zero(),
-    overrides?.globals ?? GlobalVariables.empty(),
-    overrides?.isStaticCall ?? false,
-    overrides?.calldata ?? new CallDataArray([]),
-    overrides?.config ?? PublicSimulatorConfig.empty(),
-  );
-}
-
-/**
- * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
- */
-export function initGlobalVariables(overrides?: Partial<GlobalVariables>): GlobalVariables {
-  return new GlobalVariables(
-    overrides?.chainId ?? Fr.zero(),
-    overrides?.version ?? Fr.zero(),
-    overrides?.blockNumber ?? BlockNumber.ZERO,
-    overrides?.slotNumber ?? SlotNumber.ZERO,
-    overrides?.timestamp ?? 0n,
-    overrides?.coinbase ?? EthAddress.ZERO,
-    overrides?.feeRecipient ?? AztecAddress.zero(),
-    overrides?.gasFees ?? GasFees.empty(),
-  );
-}
-
-/**
- * Create an empty instance of the Machine State where all values are set to a large enough amount, unless overridden in the overrides object
- */
-export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
-  return AvmMachineState.fromState({
-    l2GasLeft: overrides?.l2GasLeft ?? AVM_MAX_PROCESSABLE_L2_GAS,
-    daGasLeft: overrides?.daGasLeft ?? 1e8,
-  });
-}

package/src/public/avm/index.ts

@@ -1 +0,0 @@
-export * from './avm_simulator.js';

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

@@ -1,286 +0,0 @@
-import { MAX_ETH_ADDRESS_VALUE } from '@aztec/constants';
-
-import { NullifierCollisionError } from '../../side_effect_errors.js';
-import type { AvmContext } from '../avm_context.js';
-import { TypeTag, Uint1 } from '../avm_memory_types.js';
-import { InstructionExecutionError, StaticCallAlterationError } from '../errors.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 addressingMode: number,
-    private noteHashOffset: number,
-    private leafIndexOffset: number,
-    private existsOffset: 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.noteHashOffset, this.leafIndexOffset, this.existsOffset];
-    const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.FIELD, noteHashOffset);
-    memory.checkTag(TypeTag.UINT64, 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).toBigInt();
-
-    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 addressingMode: number,
-    private noteHashOffset: 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.noteHashOffset];
-    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];
-
-  constructor(
-    private addressingMode: number,
-    private siloedNullifierOffset: number,
-    private existsOffset: 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.siloedNullifierOffset, this.existsOffset];
-    const [siloedNullifierOffset, existsOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.FIELD, siloedNullifierOffset);
-
-    const siloedNullifier = memory.get(siloedNullifierOffset).toFr();
-    const exists = await context.persistableState.checkSiloedNullifierExists(siloedNullifier);
-
-    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 addressingMode: number,
-    private nullifierOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    if (context.environment.isStaticCall) {
-      throw new StaticCallAlterationError();
-    }
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.nullifierOffset];
-    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 addressingMode: number,
-    private msgHashOffset: number,
-    private msgLeafIndexOffset: number,
-    private existsOffset: 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.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
-    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTag(TypeTag.FIELD, msgHashOffset);
-    memory.checkTag(TypeTag.UINT64, msgLeafIndexOffset);
-
-    const msgHash = memory.get(msgHashOffset).toFr();
-    const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
-    const exists = await context.persistableState.checkL1ToL2MessageExists(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 addressingMode: number,
-    private logSizeOffset: number,
-    private logOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    if (context.environment.isStaticCall) {
-      throw new StaticCallAlterationError();
-    }
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.logSizeOffset, this.logOffset];
-    const [logSizeOffset, logOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.UINT32, logSizeOffset);
-    const logSize = memory.get(logSizeOffset).toNumber();
-
-    const contractAddress = context.environment.address;
-
-    context.machineState.consumeGas(this.dynamicGasCost(logSize));
-    memory.checkTagsRange(TypeTag.FIELD, logOffset, 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 addressingMode: 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;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.recipientOffset, this.contentOffset];
-    const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
-    memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
-
-    const recipient = memory.get(recipientOffset).toFr();
-
-    if (recipient.toBigInt() > MAX_ETH_ADDRESS_VALUE) {
-      throw new InstructionExecutionError(`SENDL2TOL1MSG: Recipient address is too large`);
-    }
-    const content = memory.get(contentOffset).toFr();
-    context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
-  }
-}

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

@@ -1,111 +0,0 @@
-import { AVM_MAX_OPERANDS } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import type { Tuple } from '@aztec/foundation/serialize';
-
-import { strict as assert } from 'assert';
-
-import { MemoryValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
-import { RelativeAddressOutOfRangeError, TagCheckError } 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 possible operand. */
-    private readonly modePerOperand: Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>,
-  ) {}
-
-  public static fromModes(modes: AddressingMode[]): Addressing {
-    assert(modes.length <= AVM_MAX_OPERANDS, 'Too many operands for addressing mode');
-    return new Addressing(padArrayEnd(modes, AddressingMode.DIRECT, AVM_MAX_OPERANDS));
-  }
-
-  public static fromWire(wireModes: number): Addressing {
-    // The modes are stored in the wire format as one or two bytes, with each two bits representing the modes for an operand.
-    // Even bits are indirect, odd bits are relative.
-    const modes = new Array<AddressingMode>(AVM_MAX_OPERANDS);
-    for (let i = 0; i < AVM_MAX_OPERANDS; i++) {
-      modes[i] =
-        (((wireModes >> (i * 2)) & 1) * AddressingMode.INDIRECT) |
-        (((wireModes >> (i * 2 + 1)) & 1) * AddressingMode.RELATIVE);
-    }
-    // Casting the array to tuple since it should be more performant than using makeTuple
-    return new Addressing(modes as Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>);
-  }
-
-  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 * 2);
-      }
-      if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
-        wire |= 1 << (i * 2 + 1);
-      }
-    }
-    return wire;
-  }
-
-  public indirectOperandsCount(): number {
-    return this.modePerOperand.filter(mode => mode & AddressingMode.INDIRECT).length;
-  }
-
-  public relativeOperandsCount(): number {
-    return this.modePerOperand.filter(mode => mode & AddressingMode.RELATIVE).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 and the resolved offsets are guaranteed to be valid addresses.
-   * @throws An error if any step failed. Should be treated as a black box.
-   */
-  public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
-    const resolved: number[] = new Array(offsets.length);
-    // These will be read (once) if we have any relative operands.
-    let baseAddr: MemoryValue | undefined;
-
-    for (const [i, offset] of offsets.entries()) {
-      const mode = this.modePerOperand[i];
-      // The given offsets are assumed to be valid addresses.
-      resolved[i] = offset;
-      if (mode & AddressingMode.RELATIVE) {
-        if (!baseAddr) {
-          baseAddr = mem.get(0);
-          const baseAddrTag = baseAddr.getTag();
-          if (!TaggedMemory.isValidMemoryAddressTag(baseAddrTag!)) {
-            throw TagCheckError.forBaseAddress(TypeTag[baseAddrTag!]);
-          }
-        }
-        // Here we know that resolved[i] is at most 32 bits and baseAddr is at most 32 bits.
-        // Therefore, the addition is safe since the `number` type fits more than 33 bits.
-        resolved[i] += Number(baseAddr.toBigInt());
-        if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
-          throw new RelativeAddressOutOfRangeError(Number(baseAddr.toBigInt()), offset);
-        }
-      }
-      if (mode & AddressingMode.INDIRECT) {
-        // At this point we know that resolved[i] is a valid memory address.
-        const resolvedValue = mem.get(resolved[i]);
-        const resolvedTag = resolvedValue.getTag();
-
-        // Final check.
-        if (!TaggedMemory.isValidMemoryAddressTag(resolvedTag)) {
-          throw TagCheckError.forIndirectAddress(resolved[i], TypeTag[resolvedTag]);
-        }
-
-        resolved[i] = Number(resolvedValue.toBigInt());
-      }
-    }
-    return resolved;
-  }
-}

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

@@ -1,129 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import {
-  type Field,
-  type IntegralValue,
-  type MemoryValue,
-  TaggedMemory,
-  type TaggedMemoryInterface,
-  TypeTag,
-} from '../avm_memory_types.js';
-import { ArithmeticError } from '../errors.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { ThreeOperandInstruction } from './instruction_impl.js';
-
-export abstract class ThreeOperandArithmeticInstruction 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 a = memory.get(aOffset);
-    const b = memory.get(bOffset);
-
-    const dest = this.compute(a, b);
-    memory.set(dstOffset, dest);
-  }
-
-  protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
-  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-  }
-}
-
-export class Add extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'ADD';
-  static readonly opcode = Opcode.ADD_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    return a.add(b);
-  }
-}
-
-export class Sub extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'SUB';
-  static readonly opcode = Opcode.SUB_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    return a.sub(b);
-  }
-}
-
-export class Mul extends ThreeOperandArithmeticInstruction {
-  static type: string = 'MUL';
-  static readonly opcode = Opcode.MUL_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    return a.mul(b);
-  }
-}
-
-export class Div extends ThreeOperandArithmeticInstruction {
-  static type: string = 'DIV';
-  static readonly opcode = Opcode.DIV_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    if (b.toBigInt() === 0n) {
-      throw new ArithmeticError('Division by zero');
-    }
-
-    return a.div(b);
-  }
-
-  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
-  }
-}
-
-export class FieldDiv extends ThreeOperandArithmeticInstruction {
-  static type: string = 'FDIV';
-  static readonly opcode = Opcode.FDIV_8; // FIXME: needed for gas.
-
-  protected compute(a: Field, b: Field): Field {
-    if (b.toBigInt() === 0n) {
-      throw new ArithmeticError('Division by zero');
-    }
-    return a.fdiv(b);
-  }
-
-  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-    memory.checkTag(TypeTag.FIELD, aOffset); // Follows that bOffset has also tag of type Field
-  }
-}
-
-export class Shl extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'SHL';
-  static readonly opcode = Opcode.SHL_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.shl(b);
-  }
-
-  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
-  }
-}
-
-export class Shr extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'SHR';
-  static readonly opcode = Opcode.SHR_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.shr(b);
-  }
-
-  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
-  }
-}