@aztec/simulator 0.24.0 → 0.26.2

package/src/avm/journal/public_storage.ts

@@ -0,0 +1,149 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import type { PublicStateDB } from '../../index.js';
+
+/**
+ * A class to manage public storage reads and writes during a contract call's AVM simulation.
+ * Maintains a storage write cache, and ensures that reads fall back to the correct source.
+ * When a contract call completes, its storage cache can be merged into its parent's.
+ */
+export class PublicStorage {
+  /** Cached storage writes. */
+  private cache: PublicStorageCache;
+  /** Parent's storage cache. Checked on cache-miss. */
+  private readonly parentCache: PublicStorageCache | undefined;
+  /** Reference to node storage. Checked on parent cache-miss. */
+  private readonly hostPublicStorage: PublicStateDB;
+
+  constructor(hostPublicStorage: PublicStateDB, parent?: PublicStorage) {
+    this.hostPublicStorage = hostPublicStorage;
+    this.parentCache = parent?.cache;
+    this.cache = new PublicStorageCache();
+  }
+
+  /**
+   * Get the pending storage.
+   */
+  public getCache() {
+    return this.cache;
+  }
+
+  /**
+   * Read a value from storage.
+   * 1. Check cache.
+   * 2. Check parent's cache.
+   * 3. Fall back to the host state.
+   * 4. Not found! Value has never been written to before. Flag it as non-existent and return value zero.
+   *
+   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns exists: whether the slot has EVER been written to before, value: the latest value written to slot, or 0 if never written to before
+   */
+  public async read(storageAddress: Fr, slot: Fr): Promise<[/*exists=*/ boolean, /*value=*/ Fr]> {
+    // First try check this storage cache
+    let value = this.cache.read(storageAddress, slot);
+    // Then try parent's storage cache (if it exists / written to earlier in this TX)
+    if (!value && this.parentCache) {
+      value = this.parentCache?.read(storageAddress, slot);
+    }
+    // Finally try the host's Aztec state (a trip to the database)
+    if (!value) {
+      value = await this.hostPublicStorage.storageRead(storageAddress, slot);
+    }
+    // if value is undefined, that means this slot has never been written to!
+    const exists = value !== undefined;
+    const valueOrZero = exists ? value : Fr.ZERO;
+    return Promise.resolve([exists, valueOrZero]);
+  }
+
+  /**
+   * Stage a storage write.
+   *
+   * @param storageAddress - the address of the contract whose storage is being written to
+   * @param slot - the slot in the contract's storage being written to
+   * @param value - the value being written to the slot
+   */
+  public write(storageAddress: Fr, key: Fr, value: Fr) {
+    this.cache.write(storageAddress, key, value);
+  }
+
+  /**
+   * Merges another PublicStorage's cache (pending writes) into this one.
+   *
+   * @param incomingPublicStorage - the incoming public storage to merge into this instance's
+   */
+  public acceptAndMerge(incomingPublicStorage: PublicStorage) {
+    this.cache.acceptAndMerge(incomingPublicStorage.cache);
+  }
+}
+
+/**
+ * A class to cache writes to public storage during a contract call's AVM simulation.
+ * "Writes" update a map, "reads" check that map or return undefined.
+ * An instance of this class can merge another instance's staged writes into its own.
+ */
+class PublicStorageCache {
+  /**
+   * Map for staging storage writes.
+   * One inner-map per contract storage address,
+   * mapping storage slot to latest staged write value.
+   */
+  public cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
+  // FIXME: storage ^ should be private, but its value is used in tests for "currentStorageValue"
+
+  /**
+   * Read a staged value from storage, if it has been previously written to.
+   *
+   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns the latest value written to slot, or undefined if no value has been written
+   */
+  public read(storageAddress: Fr, slot: Fr): Fr | undefined {
+    return this.cachePerContract.get(storageAddress.toBigInt())?.get(slot.toBigInt());
+  }
+
+  /**
+   * Stage a storage write.
+   *
+   * @param storageAddress - the address of the contract whose storage is being written to
+   * @param slot - the slot in the contract's storage being written to
+   * @param value - the value being written to the slot
+   */
+  public write(storageAddress: Fr, slot: Fr, value: Fr) {
+    let cacheAtContract = this.cachePerContract.get(storageAddress.toBigInt());
+    if (!cacheAtContract) {
+      // If this contract's storage has no staged modifications, create a new inner map to store them
+      cacheAtContract = new Map();
+      this.cachePerContract.set(storageAddress.toBigInt(), cacheAtContract);
+    }
+    cacheAtContract.set(slot.toBigInt(), value);
+  }
+
+  /**
+   * Merges another cache's staged writes into this instance's cache.
+   *
+   * Staged modifications in "incoming" take precedence over those
+   * present in "this" as they are assumed to occur after this' writes.
+   *
+   * In practice, "this" is a parent call's storage cache, and "incoming" is a nested call's.
+   *
+   * @param incomingStorageCache - the incoming storage write cache to merge into this instance's
+   */
+  public acceptAndMerge(incomingStorageCache: PublicStorageCache) {
+    // Iterate over all incoming contracts with staged writes.
+    for (const [incomingAddress, incomingCacheAtContract] of incomingStorageCache.cachePerContract) {
+      const thisCacheAtContract = this.cachePerContract.get(incomingAddress);
+      if (!thisCacheAtContract) {
+        // The contract has no storage writes staged here
+        // so just accept the incoming cache as-is for this contract.
+        this.cachePerContract.set(incomingAddress, incomingCacheAtContract);
+      } else {
+        // "Incoming" and "this" both have staged writes for this contract.
+        // Merge in incoming staged writes, giving them precedence over this'.
+        for (const [slot, value] of incomingCacheAtContract) {
+          thisCacheAtContract.set(slot, value);
+        }
+      }
+    }
+  }
+}

package/src/avm/journal/trace.ts

@@ -0,0 +1,223 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import { TracedL1toL2MessageCheck, TracedNoteHashCheck, TracedNullifierCheck } from './trace_types.js';
+
+export class WorldStateAccessTrace {
+  public accessCounter: number;
+  //public contractCalls: Array<TracedContractCall> = [];
+
+  //public publicStorageReads: Array<TracedPublicStorageRead> = [];
+  public publicStorageReads: Map<bigint, Map<bigint, Fr[]>> = new Map();
+  //public publicStorageWrites: Array<TracedPublicStorageWrite> = [];
+  public publicStorageWrites: Map<bigint, Map<bigint, Fr[]>> = new Map();
+
+  public noteHashChecks: TracedNoteHashCheck[] = [];
+  //public newNoteHashes: TracedNoteHash[] = [];
+  public newNoteHashes: Fr[] = [];
+  public nullifierChecks: TracedNullifierCheck[] = [];
+  //public newNullifiers: TracedNullifier[] = [];
+  public newNullifiers: Fr[] = [];
+  public l1ToL2MessageChecks: TracedL1toL2MessageCheck[] = [];
+  //public archiveChecks: TracedArchiveLeafCheck[] = [];
+
+  constructor(parentTrace?: WorldStateAccessTrace) {
+    this.accessCounter = parentTrace ? parentTrace.accessCounter : 0;
+  }
+
+  public getAccessCounter() {
+    return this.accessCounter;
+  }
+
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr /*, _exists: boolean*/) {
+    // TODO(4805): check if some threshold is reached for max storage reads
+    // (need access to parent length, or trace needs to be initialized with parent's contents)
+    //const traced: TracedPublicStorageRead = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  slot,
+    //  value,
+    //  exists,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.publicStorageReads.push(traced);
+    this.journalRead(storageAddress, slot, value);
+    this.incrementAccessCounter();
+  }
+
+  public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
+    // TODO(4805): check if some threshold is reached for max storage writes
+    // (need access to parent length, or trace needs to be initialized with parent's contents)
+    //const traced: TracedPublicStorageWrite = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  slot,
+    //  value,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.publicStorageWrites.push(traced);
+    this.journalWrite(storageAddress, slot, value);
+    this.incrementAccessCounter();
+  }
+
+  public traceNoteHashCheck(storageAddress: Fr, noteHash: Fr, exists: boolean, leafIndex: Fr) {
+    const traced: TracedNoteHashCheck = {
+      callPointer: Fr.ZERO, // FIXME
+      storageAddress,
+      noteHash,
+      exists,
+      counter: new Fr(this.accessCounter),
+      endLifetime: Fr.ZERO,
+      leafIndex,
+    };
+    this.noteHashChecks.push(traced);
+    this.incrementAccessCounter();
+  }
+
+  public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
+    // TODO(4805): check if some threshold is reached for max new note hash
+    //const traced: TracedNoteHash = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  noteHash,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.newNoteHashes.push(traced);
+    this.newNoteHashes.push(noteHash);
+    this.incrementAccessCounter();
+  }
+
+  public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, exists: boolean, isPending: boolean, leafIndex: Fr) {
+    // TODO(4805): check if some threshold is reached for max new nullifier
+    const traced: TracedNullifierCheck = {
+      callPointer: Fr.ZERO, // FIXME
+      storageAddress,
+      nullifier,
+      exists,
+      counter: new Fr(this.accessCounter),
+      endLifetime: Fr.ZERO,
+      isPending,
+      leafIndex,
+    };
+    this.nullifierChecks.push(traced);
+    this.incrementAccessCounter();
+  }
+
+  public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
+    // TODO(4805): check if some threshold is reached for max new nullifier
+    //const traced: TracedNullifier = {
+    //  callPointer: Fr.ZERO,
+    //  storageAddress,
+    //  nullifier,
+    //  counter: new Fr(this.accessCounter),
+    //  endLifetime: Fr.ZERO,
+    //};
+    //this.newNullifiers.push(traced);
+    this.newNullifiers.push(nullifier);
+    this.incrementAccessCounter();
+  }
+
+  public traceL1ToL2MessageCheck(msgHash: Fr, msgLeafIndex: Fr, exists: boolean) {
+    // TODO(4805): check if some threshold is reached for max message reads
+    const traced: TracedL1toL2MessageCheck = {
+      //callPointer: Fr.ZERO, // FIXME
+      leafIndex: msgLeafIndex,
+      msgHash: msgHash,
+      exists: exists,
+      //endLifetime: Fr.ZERO, // FIXME
+    };
+    this.l1ToL2MessageChecks.push(traced);
+    this.incrementAccessCounter();
+  }
+
+  private incrementAccessCounter() {
+    this.accessCounter++;
+  }
+
+  /**
+   * Merges another trace into this one
+   *
+   * - Public state journals (r/w logs), with the accessing being appended in chronological order
+   * - Utxo objects are concatenated
+   *
+   * @param incomingTrace - the incoming trace to merge into this instance
+   */
+  public acceptAndMerge(incomingTrace: WorldStateAccessTrace) {
+    // Merge storage read and write journals
+    mergeContractJournalMaps(this.publicStorageReads, incomingTrace.publicStorageReads);
+    mergeContractJournalMaps(this.publicStorageWrites, incomingTrace.publicStorageWrites);
+    // Merge new note hashes and nullifiers
+    this.noteHashChecks = this.noteHashChecks.concat(incomingTrace.noteHashChecks);
+    this.newNoteHashes = this.newNoteHashes.concat(incomingTrace.newNoteHashes);
+    this.nullifierChecks = this.nullifierChecks.concat(incomingTrace.nullifierChecks);
+    this.newNullifiers = this.newNullifiers.concat(incomingTrace.newNullifiers);
+    this.l1ToL2MessageChecks = this.l1ToL2MessageChecks.concat(incomingTrace.l1ToL2MessageChecks);
+    // it is assumed that the incoming trace was initialized with this as parent, so accept counter
+    this.accessCounter = incomingTrace.accessCounter;
+  }
+
+  /**
+   * We want to keep track of all performed reads in the journal
+   * This information is hinted to the avm circuit
+
+   * @param contractAddress -
+   * @param key -
+   * @param value -
+   */
+  journalUpdate(map: Map<bigint, Map<bigint, Fr[]>>, contractAddress: Fr, key: Fr, value: Fr): void {
+    let contractMap = map.get(contractAddress.toBigInt());
+    if (!contractMap) {
+      contractMap = new Map<bigint, Array<Fr>>();
+      map.set(contractAddress.toBigInt(), contractMap);
+    }
+
+    let accessArray = contractMap.get(key.toBigInt());
+    if (!accessArray) {
+      accessArray = new Array<Fr>();
+      contractMap.set(key.toBigInt(), accessArray);
+    }
+    accessArray.push(value);
+  }
+
+  // Create an instance of journalUpdate that appends to the read array
+  private journalRead = this.journalUpdate.bind(this, this.publicStorageReads);
+  // Create an instance of journalUpdate that appends to the writes array
+  private journalWrite = this.journalUpdate.bind(this, this.publicStorageWrites);
+}
+
+/**
+ * Merges two contract journalling maps together
+ * For read maps, we just append the childMap arrays into the host map arrays, as the order is important
+ *
+ * @param hostMap - The map to be merged into
+ * @param childMap - The map to be merged from
+ */
+function mergeContractJournalMaps(hostMap: Map<bigint, Map<bigint, Fr[]>>, childMap: Map<bigint, Map<bigint, Fr[]>>) {
+  for (const [key, value] of childMap) {
+    const map1Value = hostMap.get(key);
+    if (!map1Value) {
+      hostMap.set(key, value);
+    } else {
+      mergeStorageJournalMaps(map1Value, value);
+    }
+  }
+}
+
+/**
+ * Merge two storage journalling maps together (for a particular contract).
+ *
+ * @param hostMap - The map to be merge into
+ * @param childMap - The map to be merged from
+ */
+function mergeStorageJournalMaps(hostMap: Map<bigint, Fr[]>, childMap: Map<bigint, Fr[]>) {
+  for (const [key, value] of childMap) {
+    const readArr = hostMap.get(key);
+    if (!readArr) {
+      hostMap.set(key, value);
+    } else {
+      hostMap.set(key, readArr?.concat(...value));
+    }
+  }
+}

package/src/avm/journal/trace_types.ts

@@ -0,0 +1,79 @@
+import { Fr } from '@aztec/foundation/fields';
+
+//export type TracedContractCall = {
+//  callPointer: Fr;
+//  address: Fr;
+//  storageAddress: Fr;
+//  endLifetime: Fr;
+//};
+//
+//export type TracedPublicStorageRead = {
+//  callPointer: Fr;
+//  storageAddress: Fr;
+//  exists: boolean;
+//  slot: Fr;
+//  value: Fr;
+//  counter: Fr;
+//  endLifetime: Fr;
+//};
+//
+//export type TracedPublicStorageWrite = {
+//  callPointer: Fr;
+//  storageAddress: Fr;
+//  slot: Fr;
+//  value: Fr;
+//  counter: Fr;
+//  endLifetime: Fr;
+//};
+//
+export type TracedNoteHashCheck = {
+  callPointer: Fr;
+  storageAddress: Fr;
+  leafIndex: Fr;
+  noteHash: Fr;
+  exists: boolean;
+  counter: Fr;
+  endLifetime: Fr;
+};
+//
+//export type TracedNoteHash = {
+//  callPointer: Fr;
+//  storageAddress: Fr;
+//  noteHash: Fr;
+//  counter: Fr;
+//  endLifetime: Fr;
+//};
+
+export type TracedNullifierCheck = {
+  callPointer: Fr;
+  storageAddress: Fr;
+  nullifier: Fr;
+  exists: boolean;
+  counter: Fr;
+  endLifetime: Fr;
+  // the fields below are relevant only to the public kernel
+  // and are therefore omitted from VM inputs
+  isPending: boolean;
+  leafIndex: Fr;
+};
+
+//export type TracedNullifier = {
+//  callPointer: Fr;
+//  storageAddress: Fr;
+//  nullifier: Fr;
+//  counter: Fr;
+//  endLifetime: Fr;
+//};
+
+export type TracedL1toL2MessageCheck = {
+  //callPointer: Fr;
+  leafIndex: Fr;
+  msgHash: Fr;
+  exists: boolean;
+  //endLifetime: Fr;
+};
+
+//export type TracedArchiveLeafCheck = {
+//  leafIndex: Fr;
+//  leaf: Fr;
+//};

package/src/avm/opcodes/accrued_substate.ts

@@ -1,8 +1,49 @@
 import type { AvmContext } from '../avm_context.js';
+import { Uint8 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { NullifierCollisionError } from '../journal/nullifiers.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 import { StaticCallStorageAlterError } from './storage.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.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private noteHashOffset: number,
+    private leafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    // 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 exists = await context.persistableState.checkNoteHashExists(
+      context.environment.storageAddress,
+      noteHash,
+      leafIndex,
+    );
+    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+
+    context.machineState.incrementPc();
+  }
+}
+
 export class EmitNoteHash extends Instruction {
   static type: string = 'EMITNOTEHASH';
   static readonly opcode: Opcode = Opcode.EMITNOTEHASH;
@@ -19,7 +60,27 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = context.machineState.memory.get(this.noteHashOffset).toFr();
-    context.worldState.writeNoteHash(noteHash);
+    context.persistableState.writeNoteHash(noteHash);
+
+    context.machineState.incrementPc();
+  }
+}
+
+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.UINT32, OperandType.UINT32];
+
+  constructor(private indirect: number, private nullifierOffset: number, private existsOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const nullifier = context.machineState.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));
 
     context.machineState.incrementPc();
   }
@@ -41,7 +102,49 @@ export class EmitNullifier extends Instruction {
     }
 
     const nullifier = context.machineState.memory.get(this.nullifierOffset).toFr();
-    context.worldState.writeNullifier(nullifier);
+    try {
+      await context.persistableState.writeNullifier(context.environment.storageAddress, 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} (storage address: ${context.environment.storageAddress}).`,
+        );
+      } else {
+        throw e;
+      }
+    }
+
+    context.machineState.incrementPc();
+  }
+}
+
+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.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private msgHashOffset: number,
+    private msgLeafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    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();
+    const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
+    context.machineState.memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
     context.machineState.incrementPc();
   }
@@ -51,9 +154,20 @@ export class EmitUnencryptedLog extends Instruction {
   static type: string = 'EMITUNENCRYPTEDLOG';
   static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
-
-  constructor(private indirect: number, private logOffset: number, private logSize: number) {
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private eventSelectorOffset: number,
+    private logOffset: number,
+    private logSize: number,
+  ) {
     super();
   }
 
@@ -62,8 +176,15 @@ export class EmitUnencryptedLog extends Instruction {
       throw new StaticCallStorageAlterError();
     }
 
-    const log = context.machineState.memory.getSlice(this.logOffset, this.logSize).map(f => f.toFr());
-    context.worldState.writeLog(log);
+    const [eventSelectorOffset, logOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.eventSelectorOffset, this.logOffset],
+      context.machineState.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());
+    context.persistableState.writeLog(contractAddress, event, log);
 
     context.machineState.incrementPc();
   }
@@ -75,7 +196,7 @@ export class SendL2ToL1Message extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
 
-  constructor(private indirect: number, private msgOffset: number, private msgSize: number) {
+  constructor(private indirect: number, private recipientOffset: number, private contentOffset: number) {
     super();
   }
 
@@ -84,8 +205,9 @@ export class SendL2ToL1Message extends Instruction {
       throw new StaticCallStorageAlterError();
     }
 
-    const msg = context.machineState.memory.getSlice(this.msgOffset, this.msgSize).map(f => f.toFr());
-    context.worldState.writeL1Message(msg);
+    const recipient = context.machineState.memory.get(this.recipientOffset).toFr();
+    const content = context.machineState.memory.get(this.contentOffset).toFr();
+    context.persistableState.writeL1Message(recipient, content);
 
     context.machineState.incrementPc();
   }

package/src/avm/opcodes/comparators.ts

@@ -1,5 +1,4 @@
 import type { AvmContext } from '../avm_context.js';
-import { IntegralValue, TaggedMemory } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
@@ -35,10 +34,9 @@ export class Lt extends ThreeOperandInstruction {
 
   async execute(context: AvmContext): Promise<void> {
     context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-    TaggedMemory.checkIsIntegralTag(this.inTag);
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+    const a = context.machineState.memory.get(this.aOffset);
+    const b = context.machineState.memory.get(this.bOffset);
 
     // Result will be of the same type as 'a'.
     const dest = a.build(a.lt(b) ? 1n : 0n);
@@ -58,10 +56,9 @@ export class Lte extends ThreeOperandInstruction {
 
   async execute(context: AvmContext): Promise<void> {
     context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-    TaggedMemory.checkIsIntegralTag(this.inTag);
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+    const a = context.machineState.memory.get(this.aOffset);
+    const b = context.machineState.memory.get(this.bOffset);
 
     // Result will be of the same type as 'a'.
     const dest = a.build(a.equals(b) || a.lt(b) ? 1n : 0n);