@aztec/simulator 0.0.0-test.0

package/dest/public/avm/journal/public_storage.d.ts

@@ -0,0 +1,66 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PublicStateDB } from '../../../common/db_interfaces.js';
+type PublicStorageReadResult = {
+    value: Fr;
+    cached: boolean;
+};
+/**
+ * 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 declare class PublicStorage {
+    /** Reference to node storage. Checked on parent cache-miss. */
+    private readonly hostPublicStorage;
+    /** Parent's storage. Checked on this' cache-miss. */
+    private readonly parent?;
+    /** Cached storage writes. */
+    private readonly cache;
+    constructor(
+    /** Reference to node storage. Checked on parent cache-miss. */
+    hostPublicStorage: PublicStateDB, 
+    /** Parent's storage. Checked on this' cache-miss. */
+    parent?: PublicStorage | undefined);
+    /**
+     * Create a new public storage manager forked from this one
+     */
+    fork(): PublicStorage;
+    /**
+     * Read a storage value from this' cache or parent's (recursively).
+     * DOES NOT CHECK HOST STORAGE!
+     *
+     * @param contractAddress - the address of the contract whose storage is being read from
+     * @param slot - the slot in the contract's storage being read from
+     * @returns value: the latest value written according to this cache or the parent's. undefined on cache miss.
+     */
+    readHereOrParent(contractAddress: AztecAddress, slot: Fr): Fr | undefined;
+    /**
+     * Read a value from storage.
+     * 1. Check cache.
+     * 2. Check parent 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 contractAddress - 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
+     */
+    read(contractAddress: AztecAddress, slot: Fr): Promise<PublicStorageReadResult>;
+    /**
+     * Stage a storage write.
+     *
+     * @param contractAddress - 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
+     */
+    write(contractAddress: AztecAddress, slot: Fr, value: Fr): void;
+    /**
+     * Merges another PublicStorage's cache (pending writes) into this one.
+     *
+     * @param incomingPublicStorage - the incoming public storage to merge into this instance's
+     */
+    acceptAndMerge(incomingPublicStorage: PublicStorage): void;
+}
+export {};
+//# sourceMappingURL=public_storage.d.ts.map

package/dest/public/avm/journal/public_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_storage.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/journal/public_storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE,KAAK,uBAAuB,GAAG;IAC7B,KAAK,EAAE,EAAE,CAAC;IACV,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,aAAa;IAKtB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,6BAA6B;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;;IAGzC,+DAA+D;IAC9C,iBAAiB,EAAE,aAAa;IACjD,qDAAqD;IACpC,MAAM,CAAC,2BAAe;IAKzC;;OAEG;IACI,IAAI;IAIX;;;;;;;OAOG;IACI,gBAAgB,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,SAAS;IAWhF;;;;;;;;;;OAUG;IACU,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAmB5F;;;;;;OAMG;IACI,KAAK,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAI/D;;;;OAIG;IACI,cAAc,CAAC,qBAAqB,EAAE,aAAa;CAG3D"}

package/dest/public/avm/journal/public_storage.js

@@ -0,0 +1,145 @@
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * 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 {
+    hostPublicStorage;
+    parent;
+    /** Cached storage writes. */ cache;
+    constructor(/** Reference to node storage. Checked on parent cache-miss. */ hostPublicStorage, /** Parent's storage. Checked on this' cache-miss. */ parent){
+        this.hostPublicStorage = hostPublicStorage;
+        this.parent = parent;
+        this.cache = new PublicStorageCache();
+    }
+    /**
+   * Create a new public storage manager forked from this one
+   */ fork() {
+        return new PublicStorage(this.hostPublicStorage, this);
+    }
+    /**
+   * Read a storage value from this' cache or parent's (recursively).
+   * DOES NOT CHECK HOST STORAGE!
+   *
+   * @param contractAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns value: the latest value written according to this cache or the parent's. undefined on cache miss.
+   */ readHereOrParent(contractAddress, slot) {
+        // First try check this storage cache
+        let value = this.cache.read(contractAddress, slot);
+        // Then try parent's storage cache
+        if (!value && this.parent) {
+            // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
+            value = this.parent.readHereOrParent(contractAddress, slot);
+        }
+        return value;
+    }
+    /**
+   * Read a value from storage.
+   * 1. Check cache.
+   * 2. Check parent 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 contractAddress - 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
+   */ async read(contractAddress, slot) {
+        let cached = false;
+        // Check this cache and parent's (recursively)
+        let value = this.readHereOrParent(contractAddress, slot);
+        // Finally try the host's Aztec state (a trip to the database)
+        if (!value) {
+            // This functions returns Fr.ZERO if it has never been written to before
+            // we explicity coalesce to Fr.ZERO in case we have some implementations that cause this to return undefined
+            value = await this.hostPublicStorage.storageRead(contractAddress, slot) ?? Fr.ZERO;
+        // TODO(dbanks12): if value retrieved from host storage, we can cache it here
+        // any future reads to the same slot can read from cache instead of more expensive
+        // DB access
+        } else {
+            cached = true;
+        }
+        // if value is Fr.ZERO here, it that means this slot has never been written to!
+        return Promise.resolve({
+            value,
+            cached
+        });
+    }
+    /**
+   * Stage a storage write.
+   *
+   * @param contractAddress - 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
+   */ write(contractAddress, slot, value) {
+        this.cache.write(contractAddress, slot, value);
+    }
+    /**
+   * Merges another PublicStorage's cache (pending writes) into this one.
+   *
+   * @param incomingPublicStorage - the incoming public storage to merge into this instance's
+   */ acceptAndMerge(incomingPublicStorage) {
+        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.
+   */ cachePerContract = new Map();
+    /**
+   * Read a staged value from storage, if it has been previously written to.
+   *
+   * @param contractAddress - 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
+   */ read(contractAddress, slot) {
+        return this.cachePerContract.get(contractAddress.toBigInt())?.get(slot.toBigInt());
+    }
+    /**
+   * Stage a storage write.
+   *
+   * @param contractAddress - 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
+   */ write(contractAddress, slot, value) {
+        let cacheAtContract = this.cachePerContract.get(contractAddress.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(contractAddress.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
+   */ acceptAndMerge(incomingStorageCache) {
+        // 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/dest/public/avm/opcodes/accrued_substate.d.ts

@@ -0,0 +1,75 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+export declare class NoteHashExists extends Instruction {
+    private indirect;
+    private noteHashOffset;
+    private leafIndexOffset;
+    private existsOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, noteHashOffset: number, leafIndexOffset: number, existsOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class EmitNoteHash extends Instruction {
+    private indirect;
+    private noteHashOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, noteHashOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class NullifierExists extends Instruction {
+    private indirect;
+    private nullifierOffset;
+    private addressOffset;
+    private existsOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, nullifierOffset: number, addressOffset: number, existsOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class EmitNullifier extends Instruction {
+    private indirect;
+    private nullifierOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, nullifierOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class L1ToL2MessageExists extends Instruction {
+    private indirect;
+    private msgHashOffset;
+    private msgLeafIndexOffset;
+    private existsOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, msgHashOffset: number, msgLeafIndexOffset: number, existsOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class EmitUnencryptedLog extends Instruction {
+    private indirect;
+    private logOffset;
+    private logSizeOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, logOffset: number, logSizeOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class SendL2ToL1Message extends Instruction {
+    private indirect;
+    private recipientOffset;
+    private contentOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, recipientOffset: number, contentOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+//# sourceMappingURL=accrued_substate.d.ts.map

package/dest/public/avm/opcodes/accrued_substate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accrued_substate.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/accrued_substate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,cAAe,SAAQ,WAAW;IAa3C,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,YAAY;IAftB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAoB;IACvC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAyB;IAEvD,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAMxB;gBAGQ,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM;IAKjB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAezD;AAED,qBAAa,YAAa,SAAQ,WAAW;IAM/B,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,cAAc;IAL5D,MAAM,CAAC,IAAI,EAAE,MAAM,CAAkB;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAuB;IAErD,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAA8D;gBAEpE,QAAQ,EAAE,MAAM,EAAU,cAAc,EAAE,MAAM;IAIvD,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAgBzD;AAED,qBAAa,eAAgB,SAAQ,WAAW;IAa5C,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,YAAY;IAftB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAqB;IACxC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAA0B;IAExD,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAMxB;gBAGQ,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM;IAKjB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAezD;AAED,qBAAa,aAAc,SAAQ,WAAW;IAMhC,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,eAAe;IAL7D,MAAM,CAAC,IAAI,EAAE,MAAM,CAAmB;IACtC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAwB;IAEtD,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAA8D;gBAEpE,QAAQ,EAAE,MAAM,EAAU,eAAe,EAAE,MAAM;IAIxD,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CA2BzD;AAED,qBAAa,mBAAoB,SAAQ,WAAW;IAahD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IAftB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAqB;IACxC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAA0B;IAExD,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAMxB;gBAGQ,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,MAAM;IAKjB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAkBzD;AAED,qBAAa,kBAAmB,SAAQ,WAAW;IAOrC,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,SAAS;IAAU,OAAO,CAAC,aAAa;IALtF,MAAM,CAAC,IAAI,EAAE,MAAM,CAAwB;IAC3C,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAA6B;IAE3D,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAkF;gBAExF,QAAQ,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM,EAAU,aAAa,EAAE,MAAM;IAIjF,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBzD;AAED,qBAAa,iBAAkB,SAAQ,WAAW;IAMpC,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,eAAe;IAAU,OAAO,CAAC,aAAa;IAL5F,MAAM,CAAC,IAAI,EAAE,MAAM,CAAmB;IACtC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAwB;IAEtD,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAkF;gBAExF,QAAQ,EAAE,MAAM,EAAU,eAAe,EAAE,MAAM,EAAU,aAAa,EAAE,MAAM;IAIvF,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBzD"}

package/dest/public/avm/opcodes/accrued_substate.js

@@ -0,0 +1,252 @@
+import { TypeTag, Uint1 } from '../avm_memory_types.js';
+import { InstructionExecutionError, StaticCallAlterationError } 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';
+export class NoteHashExists extends Instruction {
+    indirect;
+    noteHashOffset;
+    leafIndexOffset;
+    existsOffset;
+    static type = 'NOTEHASHEXISTS';
+    static opcode = Opcode.NOTEHASHEXISTS;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, noteHashOffset, leafIndexOffset, existsOffset){
+        super(), this.indirect = indirect, this.noteHashOffset = noteHashOffset, this.leafIndexOffset = leafIndexOffset, this.existsOffset = existsOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.noteHashOffset,
+            this.leafIndexOffset,
+            this.existsOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
+        memory.checkTags(TypeTag.FIELD, noteHashOffset, 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).toFr();
+        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 {
+    indirect;
+    noteHashOffset;
+    static type = 'EMITNOTEHASH';
+    static opcode = Opcode.EMITNOTEHASH;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16
+    ];
+    constructor(indirect, noteHashOffset){
+        super(), this.indirect = indirect, this.noteHashOffset = noteHashOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.noteHashOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        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 {
+    indirect;
+    nullifierOffset;
+    addressOffset;
+    existsOffset;
+    static type = 'NULLIFIEREXISTS';
+    static opcode = Opcode.NULLIFIEREXISTS;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, nullifierOffset, addressOffset, existsOffset){
+        super(), this.indirect = indirect, this.nullifierOffset = nullifierOffset, this.addressOffset = addressOffset, this.existsOffset = existsOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.nullifierOffset,
+            this.addressOffset,
+            this.existsOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        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 {
+    indirect;
+    nullifierOffset;
+    static type = 'EMITNULLIFIER';
+    static opcode = Opcode.EMITNULLIFIER;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16
+    ];
+    constructor(indirect, nullifierOffset){
+        super(), this.indirect = indirect, this.nullifierOffset = nullifierOffset;
+    }
+    async execute(context) {
+        if (context.environment.isStaticCall) {
+            throw new StaticCallAlterationError();
+        }
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.nullifierOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        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 {
+    indirect;
+    msgHashOffset;
+    msgLeafIndexOffset;
+    existsOffset;
+    static type = 'L1TOL2MSGEXISTS';
+    static opcode = Opcode.L1TOL2MSGEXISTS;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, msgHashOffset, msgLeafIndexOffset, existsOffset){
+        super(), this.indirect = indirect, this.msgHashOffset = msgHashOffset, this.msgLeafIndexOffset = msgLeafIndexOffset, this.existsOffset = existsOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.msgHashOffset,
+            this.msgLeafIndexOffset,
+            this.existsOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
+        memory.checkTags(TypeTag.FIELD, msgHashOffset, msgLeafIndexOffset);
+        const msgHash = memory.get(msgHashOffset).toFr();
+        const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
+        const exists = await context.persistableState.checkL1ToL2MessageExists(context.environment.address, msgHash, msgLeafIndex);
+        memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
+    }
+}
+export class EmitUnencryptedLog extends Instruction {
+    indirect;
+    logOffset;
+    logSizeOffset;
+    // TODO(#11124): rename unencrypted -> public
+    static type = 'EMITUNENCRYPTEDLOG';
+    static opcode = Opcode.EMITUNENCRYPTEDLOG;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, logOffset, logSizeOffset){
+        super(), this.indirect = indirect, this.logOffset = logOffset, this.logSizeOffset = logSizeOffset;
+    }
+    async execute(context) {
+        if (context.environment.isStaticCall) {
+            throw new StaticCallAlterationError();
+        }
+        const memory = context.machineState.memory;
+        const operands = [
+            this.logOffset,
+            this.logSizeOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [logOffset, logSizeOffset] = 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.gasCost(logSize));
+        const log = memory.getSlice(logOffset, logSize).map((f)=>f.toFr());
+        context.persistableState.writePublicLog(contractAddress, log);
+    }
+}
+export class SendL2ToL1Message extends Instruction {
+    indirect;
+    recipientOffset;
+    contentOffset;
+    static type = 'SENDL2TOL1MSG';
+    static opcode = Opcode.SENDL2TOL1MSG;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, recipientOffset, contentOffset){
+        super(), this.indirect = indirect, this.recipientOffset = recipientOffset, this.contentOffset = contentOffset;
+    }
+    async execute(context) {
+        if (context.environment.isStaticCall) {
+            throw new StaticCallAlterationError();
+        }
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.recipientOffset,
+            this.contentOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        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);
+    }
+}

package/dest/public/avm/opcodes/addressing_mode.d.ts

@@ -0,0 +1,27 @@
+import { type TaggedMemoryInterface } from '../avm_memory_types.js';
+export declare enum AddressingMode {
+    DIRECT = 0,
+    INDIRECT = 1,
+    RELATIVE = 2,
+    INDIRECT_RELATIVE = 3
+}
+/** A class to represent the addressing mode of an instruction. */
+export declare class Addressing {
+    /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
+    private readonly modePerOperand;
+    constructor(
+    /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
+    modePerOperand: AddressingMode[]);
+    static fromWire(wireModes: number, numOperands?: number): Addressing;
+    toWire(): number;
+    /** Returns how many operands use the given addressing mode. */
+    count(mode: AddressingMode): number;
+    /**
+     * 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.
+     */
+    resolve(offsets: number[], mem: TaggedMemoryInterface): number[];
+}
+//# sourceMappingURL=addressing_mode.d.ts.map

package/dest/public/avm/opcodes/addressing_mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressing_mode.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/addressing_mode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAGlF,oBAAY,cAAc;IACxB,MAAM,IAAI;IACV,QAAQ,IAAI;IACZ,QAAQ,IAAI;IACZ,iBAAiB,IAAI;CACtB;AAED,kEAAkE;AAClE,qBAAa,UAAU;IAEnB,mHAAmH;IACnH,OAAO,CAAC,QAAQ,CAAC,cAAc;;IAD/B,mHAAmH;IAClG,cAAc,EAAE,cAAc,EAAE;WAIrC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,GAAE,MAAU,GAAG,UAAU;IAYvE,MAAM,IAAI,MAAM;IAevB,+DAA+D;IACxD,KAAK,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM;IAI1C;;;;;OAKG;IACI,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,qBAAqB,GAAG,MAAM,EAAE;CA4BxE"}

package/dest/public/avm/opcodes/addressing_mode.js

@@ -0,0 +1,74 @@
+import { strict as assert } from 'assert';
+import { TaggedMemory } from '../avm_memory_types.js';
+import { RelativeAddressOutOfRangeError } from '../errors.js';
+export var AddressingMode = /*#__PURE__*/ function(AddressingMode) {
+    AddressingMode[AddressingMode["DIRECT"] = 0] = "DIRECT";
+    AddressingMode[AddressingMode["INDIRECT"] = 1] = "INDIRECT";
+    AddressingMode[AddressingMode["RELATIVE"] = 2] = "RELATIVE";
+    AddressingMode[AddressingMode["INDIRECT_RELATIVE"] = 3] = "INDIRECT_RELATIVE";
+    return AddressingMode;
+}({});
+/** A class to represent the addressing mode of an instruction. */ export class Addressing {
+    modePerOperand;
+    constructor(/** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */ modePerOperand){
+        this.modePerOperand = modePerOperand;
+    }
+    // TODO(facundo): 8 for backwards compatibility.
+    static fromWire(wireModes, numOperands = 8) {
+        // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
+        // The least significant bit represents the zeroth operand, and the most significant bit represents the last operand.
+        const modes = new Array(numOperands);
+        for(let i = 0; i < numOperands; i++){
+            modes[i] = (wireModes >> i & 1) * 1 | (wireModes >> i + numOperands & 1) * 2;
+        }
+        return new Addressing(modes);
+    }
+    toWire() {
+        // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
+        // The least significant bit represents the zeroth operand, and the least significant bit represents the last operand.
+        let wire = 0;
+        for(let i = 0; i < this.modePerOperand.length; i++){
+            if (this.modePerOperand[i] & 1) {
+                wire |= 1 << i;
+            }
+            if (this.modePerOperand[i] & 2) {
+                wire |= 1 << this.modePerOperand.length + i;
+            }
+        }
+        return wire;
+    }
+    /** Returns how many operands use the given addressing mode. */ count(mode) {
+        return this.modePerOperand.filter((m)=>(m & mode) !== 0).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.
+   */ resolve(offsets, mem) {
+        assert(offsets.length <= this.modePerOperand.length);
+        const resolved = new Array(offsets.length);
+        let didRelativeOnce = false;
+        let baseAddr = 0;
+        for (const [i, offset] of offsets.entries()){
+            const mode = this.modePerOperand[i];
+            resolved[i] = offset;
+            if (mode & 2) {
+                if (!didRelativeOnce) {
+                    mem.checkIsValidMemoryOffsetTag(0);
+                    baseAddr = Number(mem.get(0).toBigInt());
+                    didRelativeOnce = true;
+                }
+                resolved[i] += baseAddr;
+                if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
+                    throw new RelativeAddressOutOfRangeError(baseAddr, offset);
+                }
+            }
+            if (mode & 1) {
+                mem.checkIsValidMemoryOffsetTag(resolved[i]);
+                resolved[i] = Number(mem.get(resolved[i]).toBigInt());
+            }
+        }
+        return resolved;
+    }
+}