@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

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.map

@@ -0,0 +1 @@
+{"version":3,"file":"accrued_substate.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/accrued_substate.ts"],"names":[],"mappings":"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"}

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.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;
+    }
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/arithmetic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,KAAK,KAAK,EACV,KAAK,WAAW,EAEhB,KAAK,qBAAqB,EAE3B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,MAAM,EAAE,MAAM,+CAA+C,CAAC;AAEvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,8BAAsB,iCAAkC,SAAQ,uBAAuB;IACxE,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;IACvE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAGpF;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;CAG/D;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;CAG/D;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,IAAI,EAAE,MAAM,CAAS;IAC5B,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;CAG/D;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,IAAI,EAAE,MAAM,CAAS;IAC5B,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;cAQ3C,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F;AAED,qBAAa,QAAS,SAAQ,iCAAiC;IAC7D,MAAM,CAAC,IAAI,EAAE,MAAM,CAAU;IAC7B,MAAM,CAAC,QAAQ,CAAC,MAAM,iBAAiB;IAEvC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;cAKzB,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F"}

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

@@ -0,0 +1,73 @@
+import { TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { ArithmeticError } from '../errors.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+export class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.aOffset,
+            this.bOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+        this.checkTags(memory, aOffset, bOffset);
+        const a = memory.get(aOffset);
+        const b = memory.get(bOffset);
+        const dest = this.compute(a, b);
+        memory.set(dstOffset, dest);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        memory.checkTagsAreSame(aOffset, bOffset);
+    }
+}
+export class Add extends ThreeOperandArithmeticInstruction {
+    static type = 'ADD';
+    static opcode = Opcode.ADD_8;
+    compute(a, b) {
+        return a.add(b);
+    }
+}
+export class Sub extends ThreeOperandArithmeticInstruction {
+    static type = 'SUB';
+    static opcode = Opcode.SUB_8;
+    compute(a, b) {
+        return a.sub(b);
+    }
+}
+export class Mul extends ThreeOperandArithmeticInstruction {
+    static type = 'MUL';
+    static opcode = Opcode.MUL_8;
+    compute(a, b) {
+        return a.mul(b);
+    }
+}
+export class Div extends ThreeOperandArithmeticInstruction {
+    static type = 'DIV';
+    static opcode = Opcode.DIV_8;
+    compute(a, b) {
+        if (b.toBigInt() === 0n) {
+            throw new ArithmeticError('Division by zero');
+        }
+        return a.div(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        memory.checkTagsAreSame(aOffset, bOffset);
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
+    }
+}
+export class FieldDiv extends ThreeOperandArithmeticInstruction {
+    static type = 'FDIV';
+    static opcode = Opcode.FDIV_8;
+    compute(a, b) {
+        // return (a as Field).fdiv(b as Field);
+        return a.fdiv(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        memory.checkTagsAreSame(aOffset, bOffset);
+        memory.checkTag(TypeTag.FIELD, aOffset); // Follows that bOffset has also tag of type Field
+    }
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/bitwise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAgB,KAAK,qBAAqB,EAAW,MAAM,wBAAwB,CAAC;AAC/G,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,uBAAe,8BAA+B,SAAQ,uBAAuB;IAC9D,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;IAC7E,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAIpF;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;CAG9E;AAED,qBAAa,EAAG,SAAQ,8BAA8B;IACpD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAQ;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,eAAe;cAElB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;CAG9E;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;CAG9E;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;cAG1D,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;cAG1D,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F;AAED,qBAAa,GAAI,SAAQ,WAAW;IAOtB,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,SAAS;IAAU,OAAO,CAAC,SAAS;IANlF,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,MAAM,CAAC,QAAQ,CAAC,WAAW,gBAAgF;IAC3G,MAAM,CAAC,QAAQ,CAAC,YAAY,gBAAkF;gBAE1F,QAAQ,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM;IAI7E,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAazD"}

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

@@ -0,0 +1,106 @@
+import { TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.aOffset,
+            this.bOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+        this.checkTags(memory, aOffset, bOffset);
+        const a = memory.getAs(aOffset);
+        const b = memory.getAs(bOffset);
+        const res = this.compute(a, b);
+        memory.set(dstOffset, res);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+        memory.checkTagsAreSame(aOffset, bOffset);
+    }
+}
+export class And extends ThreeOperandBitwiseInstruction {
+    static type = 'AND';
+    static opcode = Opcode.AND_8;
+    compute(a, b) {
+        return a.and(b);
+    }
+}
+export class Or extends ThreeOperandBitwiseInstruction {
+    static type = 'OR';
+    static opcode = Opcode.OR_8;
+    compute(a, b) {
+        return a.or(b);
+    }
+}
+export class Xor extends ThreeOperandBitwiseInstruction {
+    static type = 'XOR';
+    static opcode = Opcode.XOR_8;
+    compute(a, b) {
+        return a.xor(b);
+    }
+}
+export class Shl extends ThreeOperandBitwiseInstruction {
+    static type = 'SHL';
+    static opcode = Opcode.SHL_8;
+    compute(a, b) {
+        return a.shl(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+        memory.checkTag(TypeTag.UINT8, bOffset);
+    }
+}
+export class Shr extends ThreeOperandBitwiseInstruction {
+    static type = 'SHR';
+    static opcode = Opcode.SHR_8;
+    compute(a, b) {
+        return a.shr(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+        memory.checkTag(TypeTag.UINT8, bOffset);
+    }
+}
+export class Not extends Instruction {
+    indirect;
+    srcOffset;
+    dstOffset;
+    static type = 'NOT';
+    static opcode = Opcode.NOT_8;
+    static wireFormat8 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8
+    ];
+    static wireFormat16 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, srcOffset, dstOffset){
+        super(), this.indirect = indirect, this.srcOffset = srcOffset, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.srcOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
+        TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
+        const value = memory.getAs(srcOffset);
+        const res = value.not();
+        memory.set(dstOffset, res);
+    }
+}