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

package/src/public/avm/avm_simulator_interface.ts

@@ -1,8 +0,0 @@
-/**
- * Interface for AvmSimulator to break the circular dependency between avm_context.ts and avm_simulator.ts
- */
-export interface AvmSimulatorInterface {
-  execute(): Promise<any>; // Using any here to avoid importing AvmContractCallResult
-  executeBytecode(bytecode: Buffer): Promise<any>;
-  getBytecode(): Buffer | undefined;
-}

package/src/public/avm/errors.ts

@@ -1,177 +0,0 @@
-import type { Point } from '@aztec/foundation/fields';
-import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
-
-import { ExecutionError } from '../../common/errors.js';
-import { CheckedPublicExecutionError } from '../public_errors.js';
-
-/**
- * Avm-specific errors should derive from this
- */
-export abstract class AvmExecutionError extends CheckedPublicExecutionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'AvmExecutionError';
-  }
-}
-
-export class ArithmeticError extends AvmExecutionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ArithmeticError';
-  }
-}
-
-/**
- * Error is thrown when the program counter goes to an invalid location.
- * There is no instruction at the provided pc
- */
-export class InvalidProgramCounterError extends AvmExecutionError {
-  constructor(pc: number, max: number) {
-    super(`Invalid program counter ${pc}, max is ${max}`);
-    this.name = 'InvalidProgramCounterError';
-  }
-}
-
-/**
- * Error is thrown when the program counter points to a byte
- * of an invalid opcode.
- */
-export class InvalidOpcodeError extends AvmExecutionError {
-  constructor(str: string) {
-    super(str);
-    this.name = 'InvalidOpcodeError';
-  }
-}
-
-/**
- * Error is thrown during parsing.
- */
-export class AvmParsingError extends AvmExecutionError {
-  constructor(str: string) {
-    super(str);
-    this.name = 'AvmParsingError';
-  }
-}
-
-/**
- * Error is thrown when the tag has an invalid value.
- */
-export class InvalidTagValueError extends AvmExecutionError {
-  constructor(tagValue: number) {
-    super(`Tag check failed: Tag value ${tagValue} is invalid.`);
-    this.name = 'InvalidTagValueError';
-  }
-}
-
-/**
- * Error thrown during an instruction's execution (during its execute()).
- */
-export class InstructionExecutionError extends AvmExecutionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'InstructionExecutionError';
-  }
-}
-
-/**
- * Error thrown on failed AVM memory tag check.
- */
-export class TagCheckError extends AvmExecutionError {
-  public static forBaseAddress(gotTag: string): TagCheckError {
-    return new TagCheckError(`Base address (mem[0]) is not a valid address (has tag ${gotTag})`);
-  }
-  public static forIndirectAddress(address: number, gotTag: string): TagCheckError {
-    return new TagCheckError(`Address after indirection is not a valid address (address ${address} has tag ${gotTag})`);
-  }
-  public static forOffset(offset: number, gotTag: string, expectedTag: string): TagCheckError {
-    return new TagCheckError(`Tag mismatch at offset ${offset}, got ${gotTag}, expected ${expectedTag}`);
-  }
-
-  public static forTag(gotTag: string, expectedTag: string): TagCheckError {
-    return new TagCheckError(`Tag mismatch, got ${gotTag}, expected ${expectedTag}`);
-  }
-
-  constructor(message: string) {
-    super(message);
-    this.name = 'TagCheckError';
-  }
-}
-
-/**
- * Error is thrown when a relative memory address resolved to an offset which
- * is out of range, i.e, greater than maxUint32.
- */
-export class RelativeAddressOutOfRangeError extends AvmExecutionError {
-  constructor(baseAddr: number, relOffset: number) {
-    super(`Relative address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
-    this.name = 'RelativeAddressOutOfRangeError';
-  }
-}
-
-/**
- * Error is thrown when a memory slice contains addresses which are
- * out of range, i.e, greater than maxUint32.
- */
-export class MemorySliceOutOfRangeError extends AvmExecutionError {
-  constructor(baseAddr: number, size: number) {
-    super(`Memory slice is out of range. Base address ${baseAddr}, size ${size}`);
-    this.name = 'MemorySliceOutOfRangeError';
-  }
-}
-
-/** Error thrown when out of gas. */
-export class OutOfGasError extends AvmExecutionError {
-  constructor(dimensions: string[]) {
-    super(`Not enough ${dimensions.map(d => d.toUpperCase()).join(', ')} gas left`);
-    this.name = 'OutOfGasError';
-  }
-}
-
-/**
- * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for ECADD opcode.
- */
-export class EcAddPointNotOnCurveError extends AvmExecutionError {
-  constructor(pointIndex: number, point: Point) {
-    super(`EcAdd point${pointIndex} (${point.toString()}) is not on the curve.`);
-    this.name = 'EcAddPointNotOnCurveError';
-  }
-}
-
-/**
- * Error is thrown when some inputs of ToRadixBE are not valid.
- */
-export class InvalidToRadixInputsError extends AvmExecutionError {
-  constructor(errorString: string) {
-    super(errorString);
-    this.name = 'InvalidToRadixInputsError';
-  }
-}
-
-/**
- * Error is thrown when a static call attempts to alter some state
- */
-export class StaticCallAlterationError extends InstructionExecutionError {
-  constructor() {
-    super('Static call cannot update the state, emit L2->L1 messages or generate logs');
-    this.name = 'StaticCallAlterationError';
-  }
-}
-
-/**
- * Meaningfully named alias for ExecutionError when used in the context of the AVM.
- * Maintains a recursive structure reflecting the AVM's external callstack/errorstack, where
- * options.cause is the error that caused this error (if this is not the root-cause itself).
- */
-export class AvmRevertReason extends ExecutionError {
-  constructor(message: string, failingFunction: FailingFunction, noirCallStack: NoirCallStack, options?: ErrorOptions) {
-    super(message, failingFunction, noirCallStack, options);
-  }
-}
-
-/**
- * Helper to annotate errors occurring during instruction fetching.
- */
-export function duringInstrFetch(error: Error, pc: number) {
-  error.message = `Instruction fetching error at pc ${pc}: ${error.message}`;
-  return error;
-}

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

@@ -1,116 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { encodeArguments } from '@aztec/stdlib/abi';
-import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { GasFees } from '@aztec/stdlib/gas';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import { GlobalVariables } from '@aztec/stdlib/tx';
-import { NativeWorldStateService } from '@aztec/world-state';
-
-import { SideEffectTrace } from '../../../public/side_effect_trace.js';
-import type { AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
-import { SimpleContractDataSource } from '../../fixtures/simple_contract_data_source.js';
-import { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
-import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
-import { AvmSimulator } from '../avm_simulator.js';
-import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
-import { initContext, initExecutionEnvironment } from './initializers.js';
-import {
-  DEFAULT_TIMESTAMP,
-  getContractFunctionAbi,
-  getFunctionSelector,
-  resolveContractAssertionMessage,
-} from './utils.js';
-
-const DEFAULT_GAS_FEES = new GasFees(2, 3);
-
-/**
- * A test class that extends the BaseAvmSimulationTester to enable real-app testing of the core AvmSimulator.
- * It provides an interface for simulating one top-level call at a time and maintains state between
- * subsequent top-level calls.
- */
-export class AvmSimulationTester extends BaseAvmSimulationTester {
-  constructor(
-    contractDataSource: SimpleContractDataSource,
-    merkleTrees: MerkleTreeWriteOperations,
-    private stateManager: PublicPersistableStateManager,
-  ) {
-    super(contractDataSource, merkleTrees);
-  }
-
-  static async create(
-    worldStateService: NativeWorldStateService, // make sure to close this later
-  ): Promise<AvmSimulationTester> {
-    const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await worldStateService.fork();
-    const treesDB = new PublicTreesDB(merkleTrees);
-    const contractsDB = new PublicContractsDB(contractDataSource);
-    const trace = new SideEffectTrace();
-    const firstNullifier = new Fr(420000);
-
-    const stateManager = PublicPersistableStateManager.create(
-      treesDB,
-      contractsDB,
-      trace,
-      firstNullifier,
-      DEFAULT_TIMESTAMP,
-    );
-    return new AvmSimulationTester(contractDataSource, merkleTrees, stateManager);
-  }
-
-  /**
-   * Simulate a top-level contract call.
-   */
-  async simulateCall(
-    sender: AztecAddress,
-    address: AztecAddress,
-    fnName: string,
-    args: any[],
-    isStaticCall = false,
-  ): Promise<AvmContractCallResult> {
-    const contractArtifact = await this.contractDataSource.getContractArtifact(address);
-    if (!contractArtifact) {
-      throw new Error(`Contract not found at address: ${address}`);
-    }
-    const fnSelector = await getFunctionSelector(fnName, contractArtifact);
-    const fnAbi = getContractFunctionAbi(fnName, contractArtifact);
-    const encodedArgs = encodeArguments(fnAbi!, args);
-    const calldata = [fnSelector.toField(), ...encodedArgs];
-
-    const globals = GlobalVariables.empty();
-    globals.timestamp = DEFAULT_TIMESTAMP;
-    globals.gasFees = DEFAULT_GAS_FEES;
-
-    const config = PublicSimulatorConfig.from({
-      skipFeeEnforcement: false,
-      collectDebugLogs: true,
-      collectHints: false,
-      collectStatistics: false,
-      collectCallMetadata: true,
-    });
-    const environment = initExecutionEnvironment({
-      calldata,
-      globals,
-      address,
-      sender,
-      isStaticCall,
-      config,
-    });
-    const persistableState = await this.stateManager.fork();
-    const context = initContext({ env: environment, persistableState });
-
-    // First we simulate (though it's not needed in this simple case).
-    const simulator = new AvmSimulator(context);
-    const result = await simulator.execute();
-    if (result.reverted) {
-      this.logger.error(`Error in ${fnName}:`);
-      this.logger.error(
-        resolveContractAssertionMessage(fnName, result.revertReason!, result.output, contractArtifact)!,
-      );
-    } else {
-      this.logger.info(`Simulation of function ${fnName} succeeded!`);
-      await this.stateManager.merge(persistableState);
-    }
-    return result;
-  }
-}

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

@@ -1,102 +0,0 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-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 { 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 ?? [],
-    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,288 +0,0 @@
-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 indirect: 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.indirect);
-
-    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 indirect: number,
-    private noteHashOffset: 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.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,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private indirect: number,
-    private nullifierOffset: number,
-    private addressOffset: number,
-    private existsOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
-    const [nullifierOffset, addressOffset, existsOffset] = addressing.resolve(operands, memory);
-    memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
-
-    const nullifier = memory.get(nullifierOffset).toFr();
-    const address = memory.get(addressOffset).toAztecAddress();
-    const exists = await context.persistableState.checkNullifierExists(address, nullifier);
-
-    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
-  }
-}
-
-export class EmitNullifier extends Instruction {
-  static type: string = 'EMITNULLIFIER';
-  static readonly opcode: Opcode = Opcode.EMITNULLIFIER;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
-
-  constructor(
-    private indirect: number,
-    private nullifierOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    if (context.environment.isStaticCall) {
-      throw new StaticCallAlterationError();
-    }
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    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 indirect: 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.indirect);
-
-    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 indirect: 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.indirect);
-
-    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();
-    memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
-
-    const contractAddress = context.environment.address;
-
-    context.machineState.consumeGas(this.dynamicGasCost(logSize));
-    const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
-    context.persistableState.writePublicLog(contractAddress, log);
-  }
-}
-
-export class SendL2ToL1Message extends Instruction {
-  static type: string = 'SENDL2TOL1MSG';
-  static readonly opcode: Opcode = Opcode.SENDL2TOL1MSG;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
-
-  constructor(
-    private indirect: number,
-    private recipientOffset: number,
-    private contentOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    if (context.environment.isStaticCall) {
-      throw new StaticCallAlterationError();
-    }
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    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();
-    const content = memory.get(contentOffset).toFr();
-    context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
-  }
-}