@aztec/simulator 0.32.1 → 0.33.0

package/src/avm/{avm_gas_cost.ts → avm_gas.ts}

@@ -1,20 +1,49 @@
 import { TypeTag } from './avm_memory_types.js';
+import { InstructionExecutionError } from './errors.js';
+import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 import { Opcode } from './serialization/instruction_serialization.js';
 
-/** Gas cost in L1, L2, and DA for a given instruction. */
-export type GasCost = {
+/** Gas counters in L1, L2, and DA. */
+export type Gas = {
   l1Gas: number;
   l2Gas: number;
   daGas: number;
 };
 
+/** Maps a Gas struct to gasLeft properties. */
+export function gasToGasLeft(gas: Gas) {
+  return { l1GasLeft: gas.l1Gas, l2GasLeft: gas.l2Gas, daGasLeft: gas.daGas };
+}
+
+/** Maps gasLeft properties to a gas struct. */
+export function gasLeftToGas(gasLeft: { l1GasLeft: number; l2GasLeft: number; daGasLeft: number }) {
+  return { l1Gas: gasLeft.l1GasLeft, l2Gas: gasLeft.l2GasLeft, daGas: gasLeft.daGasLeft };
+}
+
 /** Creates a new instance with all values set to zero except the ones set. */
-export function makeGasCost(gasCost: Partial<GasCost>) {
-  return { ...EmptyGasCost, ...gasCost };
+export function makeGas(gasCost: Partial<Gas>) {
+  return { ...EmptyGas, ...gasCost };
+}
+
+/** Sums together multiple instances of Gas. */
+export function sumGas(...gases: Partial<Gas>[]) {
+  return gases.reduce(
+    (acc: Gas, gas) => ({
+      l1Gas: acc.l1Gas + (gas.l1Gas ?? 0),
+      l2Gas: acc.l2Gas + (gas.l2Gas ?? 0),
+      daGas: acc.daGas + (gas.daGas ?? 0),
+    }),
+    EmptyGas,
+  );
+}
+
+/** Multiplies a gas instance by a scalar. */
+export function mulGas(gas: Partial<Gas>, scalar: number) {
+  return { l1Gas: (gas.l1Gas ?? 0) * scalar, l2Gas: (gas.l2Gas ?? 0) * scalar, daGas: (gas.daGas ?? 0) * scalar };
 }
 
-/** Gas cost of zero across all gas dimensions. */
-export const EmptyGasCost = {
+/** Zero gas across all gas dimensions. */
+export const EmptyGas: Gas = {
   l1Gas: 0,
   l2Gas: 0,
   daGas: 0,
@@ -29,12 +58,12 @@ export const DynamicGasCost = Symbol('DynamicGasCost');
 /** Temporary default gas cost. We should eventually remove all usage of this variable in favor of actual gas for each opcode. */
 const TemporaryDefaultGasCost = { l1Gas: 0, l2Gas: 10, daGas: 0 };
 
-/** Gas costs for each instruction. */
-export const GasCosts = {
-  [Opcode.ADD]: DynamicGasCost,
-  [Opcode.SUB]: DynamicGasCost,
-  [Opcode.MUL]: DynamicGasCost,
-  [Opcode.DIV]: DynamicGasCost,
+/** Base gas costs for each instruction. Additional gas cost may be added on top due to memory or storage accesses, etc. */
+export const GasCosts: Record<Opcode, Gas | typeof DynamicGasCost> = {
+  [Opcode.ADD]: TemporaryDefaultGasCost,
+  [Opcode.SUB]: TemporaryDefaultGasCost,
+  [Opcode.MUL]: TemporaryDefaultGasCost,
+  [Opcode.DIV]: TemporaryDefaultGasCost,
   [Opcode.FDIV]: TemporaryDefaultGasCost,
   [Opcode.EQ]: TemporaryDefaultGasCost,
   [Opcode.LT]: TemporaryDefaultGasCost,
@@ -64,7 +93,7 @@ export const GasCosts = {
   [Opcode.BLOCKL1GASLIMIT]: TemporaryDefaultGasCost,
   [Opcode.BLOCKL2GASLIMIT]: TemporaryDefaultGasCost,
   [Opcode.BLOCKDAGASLIMIT]: TemporaryDefaultGasCost,
-  [Opcode.CALLDATACOPY]: DynamicGasCost,
+  [Opcode.CALLDATACOPY]: TemporaryDefaultGasCost,
   // Gas
   [Opcode.L1GASLEFT]: TemporaryDefaultGasCost,
   [Opcode.L2GASLEFT]: TemporaryDefaultGasCost,
@@ -75,7 +104,7 @@ export const GasCosts = {
   [Opcode.INTERNALCALL]: TemporaryDefaultGasCost,
   [Opcode.INTERNALRETURN]: TemporaryDefaultGasCost,
   // Memory
-  [Opcode.SET]: DynamicGasCost,
+  [Opcode.SET]: TemporaryDefaultGasCost,
   [Opcode.MOV]: TemporaryDefaultGasCost,
   [Opcode.CMOV]: TemporaryDefaultGasCost,
   // World state
@@ -89,6 +118,7 @@ export const GasCosts = {
   [Opcode.HEADERMEMBER]: TemporaryDefaultGasCost,
   [Opcode.EMITUNENCRYPTEDLOG]: TemporaryDefaultGasCost,
   [Opcode.SENDL2TOL1MSG]: TemporaryDefaultGasCost,
+  [Opcode.GETCONTRACTINSTANCE]: TemporaryDefaultGasCost,
   // External calls
   [Opcode.CALL]: TemporaryDefaultGasCost,
   [Opcode.STATICCALL]: TemporaryDefaultGasCost,
@@ -100,18 +130,42 @@ export const GasCosts = {
   [Opcode.POSEIDON]: TemporaryDefaultGasCost,
   [Opcode.SHA256]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,
   [Opcode.PEDERSEN]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,t
-} as const;
+};
+
+/** Returns the fixed base gas cost for a given opcode, or throws if set to dynamic. */
+export function getBaseGasCost(opcode: Opcode): Gas {
+  const cost = GasCosts[opcode];
+  if (cost === DynamicGasCost) {
+    throw new Error(`Opcode ${Opcode[opcode]} has dynamic gas cost`);
+  }
+  return cost;
+}
+
+/** Returns the gas cost associated with the memory operations performed. */
+export function getMemoryGasCost(args: { reads?: number; writes?: number; indirect?: number }) {
+  const { reads, writes, indirect } = args;
+  const indirectCount = Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
+  const l2MemoryGasCost =
+    (reads ?? 0) * GasCostConstants.MEMORY_READ +
+    (writes ?? 0) * GasCostConstants.MEMORY_WRITE +
+    indirectCount * GasCostConstants.MEMORY_INDIRECT_READ_PENALTY;
+  return makeGas({ l2Gas: l2MemoryGasCost });
+}
 
 /** Constants used in base cost calculations. */
 export const GasCostConstants = {
-  SET_COST_PER_BYTE: 100,
-  CALLDATACOPY_COST_PER_BYTE: 10,
-  ARITHMETIC_COST_PER_BYTE: 10,
-  ARITHMETIC_COST_PER_INDIRECT_ACCESS: 5,
+  MEMORY_READ: 10,
+  MEMORY_INDIRECT_READ_PENALTY: 10,
+  MEMORY_WRITE: 100,
 };
 
+/** Returns gas cost for an operation on a given type tag based on the base cost per byte. */
+export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
+  return mulGas(baseCost, getGasCostMultiplierFromTypeTag(tag));
+}
+
 /** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */
-export function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
+function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
   switch (tag) {
     case TypeTag.UINT8:
       return 1;
@@ -127,6 +181,6 @@ export function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
       return 32;
     case TypeTag.INVALID:
     case TypeTag.UNINITIALIZED:
-      throw new Error(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
+      throw new InstructionExecutionError(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
   }
 }

package/src/avm/avm_machine_state.ts

@@ -1,6 +1,6 @@
 import { type Fr } from '@aztec/circuits.js';
 
-import { type GasCost, GasDimensions } from './avm_gas_cost.js';
+import { type Gas, GasDimensions } from './avm_gas.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { AvmContractCallResults } from './avm_message_call_result.js';
 import { OutOfGasError } from './errors.js';
@@ -59,7 +59,7 @@ export class AvmMachineState {
    * Should any of the gas dimensions get depleted, it sets all gas left to zero and triggers
    * an exceptional halt by throwing an OutOfGasError.
    */
-  public consumeGas(gasCost: Partial<GasCost>) {
+  public consumeGas(gasCost: Partial<Gas>) {
     // Assert there is enough gas on every dimension.
     const outOfGasDimensions = GasDimensions.filter(
       dimension => this[`${dimension}Left`] - (gasCost[dimension] ?? 0) < 0,
@@ -76,6 +76,13 @@ export class AvmMachineState {
     }
   }
 
+  /** Increases the gas left by the amounts specified. */
+  public refundGas(gasRefund: Partial<Gas>) {
+    for (const dimension of GasDimensions) {
+      this[`${dimension}Left`] += gasRefund[dimension] ?? 0;
+    }
+  }
+
   /**
    * Most instructions just increment PC before they complete
    */

package/src/avm/avm_memory_types.ts

@@ -1,10 +1,12 @@
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { type FunctionsOf } from '@aztec/foundation/types';
 
 import { strict as assert } from 'assert';
 
-import { TagCheckError } from './errors.js';
+import { InstructionExecutionError, TagCheckError } from './errors.js';
+import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 
 /** MemoryValue gathers the common operations for all memory types. */
 export abstract class MemoryValue {
@@ -30,6 +32,11 @@ export abstract class MemoryValue {
     return new Fr(this.toBigInt());
   }
 
+  // To number. Throws if exceeds max safe int.
+  public toNumber(): number {
+    return this.toFr().toNumber();
+  }
+
   public toString(): string {
     return `${this.constructor.name}(0x${this.toBigInt().toString(16)})`;
   }
@@ -198,10 +205,16 @@ export enum TypeTag {
   INVALID,
 }
 
+// Lazy interface definition for tagged memory
+export type TaggedMemoryInterface = FunctionsOf<TaggedMemory>;
+
 // TODO: Consider automatic conversion when getting undefined values.
-export class TaggedMemory {
+export class TaggedMemory implements TaggedMemoryInterface {
   static readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:memory');
 
+  // Whether to track and validate memory accesses for each instruction.
+  static readonly TRACK_MEMORY_ACCESSES = process.env.NODE_ENV === 'test';
+
   // FIXME: memory should be 2^32, but TS doesn't allow for arrays that big.
   static readonly MAX_MEMORY_SIZE = Number((1n << 32n) - 2n);
   private _mem: MemoryValue[];
@@ -211,6 +224,11 @@ export class TaggedMemory {
     this._mem = [];
   }
 
+  /** Returns a MeteredTaggedMemory instance to track the number of reads and writes if TRACK_MEMORY_ACCESSES is set. */
+  public track(type: string = 'instruction') {
+    return TaggedMemory.TRACK_MEMORY_ACCESSES ? new MeteredTaggedMemory(this, type) : this;
+  }
+
   public get(offset: number): MemoryValue {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this.getAs<MemoryValue>(offset);
@@ -221,6 +239,9 @@ export class TaggedMemory {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem[offset];
     TaggedMemory.log(`get(${offset}) = ${word}`);
+    if (word === undefined) {
+      TaggedMemory.log.warn(`Memory at offset ${offset} is undefined! This might be OK if it's stack dumping.`);
+    }
     return word as T;
   }
 
@@ -229,6 +250,7 @@ export class TaggedMemory {
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
     TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    assert(!value.some(e => e === undefined), 'Memory slice contains undefined values.');
     assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
     return value;
   }
@@ -367,4 +389,110 @@ export class TaggedMemory {
         throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
     }
   }
+
+  /** No-op. Implemented here for compatibility with the MeteredTaggedMemory. */
+  public assert(_operations: Partial<MemoryOperations & { indirect: number }>) {}
+}
+
+/** Tagged memory wrapper with metering for each memory read and write operation. */
+export class MeteredTaggedMemory implements TaggedMemoryInterface {
+  private reads: number = 0;
+  private writes: number = 0;
+
+  constructor(private wrapped: TaggedMemory, private type: string = 'instruction') {}
+
+  /** Returns the number of reads and writes tracked so far and resets them to zero. */
+  public reset(): MemoryOperations {
+    const stats = { reads: this.reads, writes: this.writes };
+    this.reads = 0;
+    this.writes = 0;
+    return stats;
+  }
+
+  /**
+   * Asserts that the exact number of memory operations have been performed.
+   * Indirect represents the flags for indirect accesses: each bit set to one counts as an extra read.
+   */
+  public assert(operations: Partial<MemoryOperations & { indirect: number }>) {
+    const { reads: expectedReads, writes: expectedWrites, indirect } = { reads: 0, writes: 0, ...operations };
+
+    const totalExpectedReads = expectedReads + Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
+    const { reads: actualReads, writes: actualWrites } = this.reset();
+    if (actualReads !== totalExpectedReads) {
+      throw new InstructionExecutionError(
+        `Incorrect number of memory reads for ${this.type}: expected ${totalExpectedReads} but executed ${actualReads}`,
+      );
+    }
+    if (actualWrites !== expectedWrites) {
+      throw new InstructionExecutionError(
+        `Incorrect number of memory writes for ${this.type}: expected ${expectedWrites} but executed ${actualWrites}`,
+      );
+    }
+  }
+
+  public track(type: string = 'instruction'): MeteredTaggedMemory {
+    return new MeteredTaggedMemory(this.wrapped, type);
+  }
+
+  public get(offset: number): MemoryValue {
+    this.reads++;
+    return this.wrapped.get(offset);
+  }
+
+  public getSliceAs<T>(offset: number, size: number): T[] {
+    this.reads += size;
+    return this.wrapped.getSliceAs<T>(offset, size);
+  }
+
+  public getAs<T>(offset: number): T {
+    this.reads++;
+    return this.wrapped.getAs(offset);
+  }
+
+  public getSlice(offset: number, size: number): MemoryValue[] {
+    this.reads += size;
+    return this.wrapped.getSlice(offset, size);
+  }
+
+  public set(offset: number, v: MemoryValue): void {
+    this.writes++;
+    this.wrapped.set(offset, v);
+  }
+
+  public setSlice(offset: number, vs: MemoryValue[]): void {
+    this.writes += vs.length;
+    this.wrapped.setSlice(offset, vs);
+  }
+
+  public getSliceTags(offset: number, size: number): TypeTag[] {
+    return this.wrapped.getSliceTags(offset, size);
+  }
+
+  public getTag(offset: number): TypeTag {
+    return this.wrapped.getTag(offset);
+  }
+
+  public checkTag(tag: TypeTag, offset: number): void {
+    this.wrapped.checkTag(tag, offset);
+  }
+
+  public checkIsValidMemoryOffsetTag(offset: number): void {
+    this.wrapped.checkIsValidMemoryOffsetTag(offset);
+  }
+
+  public checkTags(tag: TypeTag, ...offsets: number[]): void {
+    this.wrapped.checkTags(tag, ...offsets);
+  }
+
+  public checkTagsRange(tag: TypeTag, startOffset: number, size: number): void {
+    this.wrapped.checkTagsRange(tag, startOffset, size);
+  }
 }
+
+/** Tracks number of memory reads and writes. */
+export type MemoryOperations = {
+  /** How many total reads are performed. Slice reads are count as one per element. */
+  reads: number;
+  /** How many total writes are performed. Slice writes are count as one per element. */
+  writes: number;
+};

package/src/avm/avm_simulator.ts

@@ -50,30 +50,32 @@ export class AvmSimulator {
    */
   public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResults> {
     assert(instructions.length > 0);
+    const { machineState } = this.context;
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
-      while (!this.context.machineState.halted) {
-        const instruction = instructions[this.context.machineState.pc];
+      while (!machineState.halted) {
+        const instruction = instructions[machineState.pc];
         assert(
           !!instruction,
           'AVM attempted to execute non-existent instruction. This should never happen (invalid bytecode or AVM simulator bug)!',
         );
 
-        this.log.debug(`@${this.context.machineState.pc} ${instruction.toString()}`);
+        const gasLeft = `l1=${machineState.l1GasLeft} l2=${machineState.l2GasLeft} da=${machineState.daGasLeft}`;
+        this.log.debug(`@${machineState.pc} (${gasLeft}) ${instruction.toString()}`);
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
-        await instruction.run(this.context);
+        await instruction.execute(this.context);
 
-        if (this.context.machineState.pc >= instructions.length) {
+        if (machineState.pc >= instructions.length) {
           this.log('Passed end of program!');
-          throw new InvalidProgramCounterError(this.context.machineState.pc, /*max=*/ instructions.length);
+          throw new InvalidProgramCounterError(machineState.pc, /*max=*/ instructions.length);
         }
       }
 
       // Return results for processing by calling context
-      const results = this.context.machineState.getResults();
+      const results = machineState.getResults();
       this.log(`Context execution results: ${results.toString()}`);
       return results;
     } catch (e) {

package/src/avm/opcodes/accrued_substate.ts

@@ -28,18 +28,23 @@ export class NoteHashExists extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // Note that this instruction accepts any type in memory, and converts to Field.
-    const noteHash = context.machineState.memory.get(this.noteHashOffset).toFr();
-    const leafIndex = context.machineState.memory.get(this.leafIndexOffset).toFr();
+    const noteHash = memory.get(this.noteHashOffset).toFr();
+    const leafIndex = memory.get(this.leafIndexOffset).toFr();
 
     const exists = await context.persistableState.checkNoteHashExists(
       context.environment.storageAddress,
       noteHash,
       leafIndex,
     );
-    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -54,14 +59,19 @@ export class EmitNoteHash extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const noteHash = context.machineState.memory.get(this.noteHashOffset).toFr();
+    const noteHash = memory.get(this.noteHashOffset).toFr();
     context.persistableState.writeNoteHash(noteHash);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -76,12 +86,17 @@ export class NullifierExists extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const nullifier = context.machineState.memory.get(this.nullifierOffset).toFr();
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const nullifier = memory.get(this.nullifierOffset).toFr();
     const exists = await context.persistableState.checkNullifierExists(context.environment.storageAddress, nullifier);
 
-    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -96,12 +111,16 @@ export class EmitNullifier extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const nullifier = context.machineState.memory.get(this.nullifierOffset).toFr();
+    const memoryOperations = { reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const nullifier = memory.get(this.nullifierOffset).toFr();
     try {
       await context.persistableState.writeNullifier(context.environment.storageAddress, nullifier);
     } catch (e) {
@@ -115,6 +134,7 @@ export class EmitNullifier extends Instruction {
       }
     }
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -140,12 +160,17 @@ export class L1ToL2MessageExists extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const msgHash = context.machineState.memory.get(this.msgHashOffset).toFr();
-    const msgLeafIndex = context.machineState.memory.get(this.msgLeafIndexOffset).toFr();
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const msgHash = memory.get(this.msgHashOffset).toFr();
+    const msgLeafIndex = memory.get(this.msgLeafIndexOffset).toFr();
     const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
-    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -171,21 +196,26 @@ export class EmitUnencryptedLog extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
+    const memoryOperations = { reads: 1 + this.logSize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     const [eventSelectorOffset, logOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.eventSelectorOffset, this.logOffset],
-      context.machineState.memory,
+      memory,
     );
 
     const contractAddress = context.environment.address;
-    const event = context.machineState.memory.get(eventSelectorOffset).toFr();
-    const log = context.machineState.memory.getSlice(logOffset, this.logSize).map(f => f.toFr());
+    const event = memory.get(eventSelectorOffset).toFr();
+    const log = memory.getSlice(logOffset, this.logSize).map(f => f.toFr());
     context.persistableState.writeLog(contractAddress, event, log);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -200,15 +230,20 @@ export class SendL2ToL1Message extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const recipient = context.machineState.memory.get(this.recipientOffset).toFr();
-    const content = context.machineState.memory.get(this.contentOffset).toFr();
+    const memoryOperations = { reads: 2, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const recipient = memory.get(this.recipientOffset).toFr();
+    const content = memory.get(this.contentOffset).toFr();
     context.persistableState.writeL1Message(recipient, content);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/addressing_mode.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert';
 
-import { type TaggedMemory } from '../avm_memory_types.js';
+import { type TaggedMemoryInterface } from '../avm_memory_types.js';
 
 export enum AddressingMode {
   DIRECT,
@@ -12,7 +12,7 @@ export enum AddressingMode {
 export class Addressing {
   public constructor(
     /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
-    public readonly modePerOperand: AddressingMode[],
+    private readonly modePerOperand: AddressingMode[],
   ) {
     assert(modePerOperand.length <= 8, 'At most 8 operands are supported');
   }
@@ -39,13 +39,18 @@ export class Addressing {
     return wire;
   }
 
+  /** Returns how many operands use the given addressing mode. */
+  public count(mode: AddressingMode): number {
+    return this.modePerOperand.filter(m => m === mode).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.
    */
-  public resolve(offsets: number[], mem: TaggedMemory): number[] {
+  public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
     assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
     for (const [i, offset] of offsets.entries()) {