@aztec/simulator 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

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, // Indirect
-    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 indirect: 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.indirect);
-
-    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,96 +0,0 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import { Point } from '@aztec/foundation/fields';
-
-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 indirect: 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.indirect);
-
-    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) {
-      dest = p2;
-    } else if (p2IsInfinite) {
-      dest = p1;
-    } 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,
-  BASEFEEPERL2GAS,
-  BASEFEEPERDAGAS,
-  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.BASEFEEPERL2GAS:
-      return new Uint128(ctx.environment.globals.gasFees.feePerL2Gas);
-    case EnvironmentVariable.BASEFEEPERDAGAS:
-      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, // indirect
-    OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // variable enum (immediate)
-  ];
-
-  constructor(
-    private indirect: 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.indirect);
-
-    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);
-  }
-}

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

@@ -1,260 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import type { AvmContractCallResult } from '../avm_contract_call_result.js';
-import { type Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-abstract class ExternalCall extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT16, // Indirect
-    OperandType.UINT16, // L2 gas offset
-    OperandType.UINT16, // DA gas offset
-    OperandType.UINT16, // Address offset
-    OperandType.UINT16, // Args offset
-    OperandType.UINT16, // Args size offset
-  ];
-
-  constructor(
-    private indirect: number,
-    private l2GasOffset: number,
-    private daGasOffset: number,
-    private addrOffset: number,
-    private argsSizeOffset: number,
-    private argsOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext) {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.l2GasOffset, this.daGasOffset, this.addrOffset, this.argsSizeOffset, this.argsOffset];
-    const [l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTags(TypeTag.UINT32, l2GasOffset);
-    memory.checkTags(TypeTag.UINT32, daGasOffset);
-    memory.checkTag(TypeTag.FIELD, addrOffset);
-    memory.checkTag(TypeTag.UINT32, argsSizeOffset);
-
-    const calldataSize = memory.get(argsSizeOffset).toNumber();
-    const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
-
-    const callAddress = memory.getAs<Field>(addrOffset);
-    // If we are already in a static call, we propagate the environment.
-    const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
-
-    // We consume the gas allocated for the nested call. The excess will be refunded later.
-    // Gas allocation is capped by the amount of gas left in the current context.
-    // We have to do some dancing here because the gas allocation is a field,
-    // but in the machine state we track gas as a number.
-    const allocatedL2Gas = Number(
-      BigIntMin(memory.get(l2GasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)),
-    );
-    const allocatedDaGas = Number(
-      BigIntMin(memory.get(daGasOffset).toBigInt(), BigInt(context.machineState.daGasLeft)),
-    );
-    const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
-    context.machineState.consumeGas(allocatedGas);
-
-    const aztecAddress = callAddress.toAztecAddress();
-    const nestedContext = await context.createNestedContractCallContext(aztecAddress, calldata, allocatedGas, callType);
-
-    const simulator = await context.provideSimulator!(nestedContext);
-    const nestedCallResults: AvmContractCallResult = await simulator.execute();
-    const success = !nestedCallResults.reverted;
-
-    // Save return/revert data for later.
-    const fullReturnData = nestedCallResults.output;
-    context.machineState.nestedReturndata = fullReturnData;
-
-    // Track the success status directly
-    context.machineState.nestedCallSuccess = success;
-
-    // Account for all instructions executed in the nested call
-    context.machineState.instrCounter += nestedCallResults.totalInstructions;
-
-    // If the nested call reverted, we try to save the reason and the revert data.
-    // This will be used by the caller to try to reconstruct the call stack.
-    // This is only a heuristic and may not always work. It is intended to work
-    // for the case where a nested call reverts and the caller always rethrows
-    // (in Noir code).
-    if (!success) {
-      context.machineState.collectedRevertInfo = {
-        revertDataRepresentative: fullReturnData,
-        recursiveRevertReason: nestedCallResults.revertReason!,
-      };
-    }
-
-    // Refund unused gas
-    context.machineState.refundGas(nestedCallResults.gasLeft);
-
-    // Merge nested call's state and trace based on whether it succeeded.
-    if (success) {
-      await context.persistableState.merge(nestedContext.persistableState);
-    } else {
-      await context.persistableState.reject(nestedContext.persistableState);
-    }
-  }
-
-  public abstract override get type(): 'CALL' | 'STATICCALL';
-}
-
-export class Call extends ExternalCall {
-  static type = 'CALL' as const;
-  static readonly opcode: Opcode = Opcode.CALL;
-
-  public get type() {
-    return Call.type;
-  }
-}
-
-export class StaticCall extends ExternalCall {
-  static type = 'STATICCALL' as const;
-  static readonly opcode: Opcode = Opcode.STATICCALL;
-
-  public get type() {
-    return StaticCall.type;
-  }
-}
-
-export class SuccessCopy extends Instruction {
-  static type: string = 'SUCCESSCOPY';
-  static readonly opcode: Opcode = Opcode.SUCCESSCOPY;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8, // Indirect (8-bit)
-    OperandType.UINT16, // dstOffset (16-bit)
-  ];
-
-  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);
-
-    // Use the direct success tracking property
-    const success = context.machineState.nestedCallSuccess;
-
-    // Write the success flag to the provided memory location
-    memory.set(dstOffset, new Uint1(success ? 1 : 0));
-  }
-}
-
-export class Return extends Instruction {
-  static type: string = 'RETURN';
-  static readonly opcode: Opcode = Opcode.RETURN;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private indirect: number,
-    private returnSizeOffset: number,
-    private returnOffset: 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.returnSizeOffset, this.returnOffset];
-    const [returnSizeOffset, returnOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTag(TypeTag.UINT32, returnSizeOffset);
-    const returnSize = memory.get(returnSizeOffset).toNumber();
-
-    const output = memory.getSlice(returnOffset, returnSize).map(word => word.toFr());
-
-    context.machineState.return(output);
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class Revert extends Instruction {
-  static type: string = 'REVERT';
-  static readonly opcode: Opcode = Opcode.REVERT_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 retSizeOffset: number,
-    private returnOffset: 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.retSizeOffset, this.returnOffset];
-    const [retSizeOffset, returnOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTag(TypeTag.UINT32, retSizeOffset);
-    const retSize = memory.get(retSizeOffset).toNumber();
-    const output = memory.getSlice(returnOffset, retSize).map(word => word.toFr());
-
-    context.machineState.revert(output);
-  }
-
-  // We don't want to increase the PC after reverting because it breaks messages.
-  // Maybe we can remove this once messages don't depend on PCs.
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-/** Returns the smaller of two bigints. */
-function BigIntMin(a: bigint, b: bigint): bigint {
-  return a < b ? a : b;
-}

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

@@ -1,145 +0,0 @@
-import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
-
-import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint32, Uint64 } 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 Poseidon2 extends Instruction {
-  static type: string = 'POSEIDON2';
-  static readonly opcode: Opcode = Opcode.POSEIDON2;
-  static readonly stateSize = 4;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private indirect: number,
-    private inputStateOffset: number,
-    private outputStateOffset: 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.inputStateOffset, this.outputStateOffset];
-
-    const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
-
-    const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
-    memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
-
-    const outputState = await poseidon2Permutation(inputState);
-    memory.setSlice(
-      outputOffset,
-      outputState.map(word => new Field(word)),
-    );
-  }
-}
-
-export class KeccakF1600 extends Instruction {
-  static type: string = 'KECCAKF1600';
-  static readonly opcode: Opcode = Opcode.KECCAKF1600;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private inputOffset: number,
-  ) {
-    super();
-  }
-
-  // pub fn keccakf1600(input: [u64; 25]) -> [u64; 25]
-  public async execute(context: AvmContext): Promise<void> {
-    const inputSize = 25;
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.dstOffset, this.inputOffset];
-    const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
-
-    const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
-    memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
-
-    const updatedState = keccakf1600(stateData);
-
-    const res = updatedState.map(word => new Uint64(word));
-    memory.setSlice(dstOffset, res);
-  }
-}
-
-export class Sha256Compression extends Instruction {
-  static type: string = 'SHA256COMPRESSION';
-  static readonly opcode: Opcode = Opcode.SHA256COMPRESSION;
-
-  // 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 outputOffset: number,
-    private stateOffset: number,
-    private inputsOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const STATE_SIZE = 8;
-    const INPUTS_SIZE = 16;
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
-    const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
-
-    // Note: size of output is same as size of state
-    const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toNumber()));
-    const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toNumber()));
-
-    memory.checkTagsRange(TypeTag.UINT32, inputsOffset, INPUTS_SIZE);
-    memory.checkTagsRange(TypeTag.UINT32, stateOffset, STATE_SIZE);
-
-    const output = sha256Compression(state, inputs);
-
-    // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)
-    const res = [...output].map(word => new Uint32(word));
-    memory.setSlice(outputOffset, res);
-  }
-}