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

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

@@ -0,0 +1,180 @@
+import { TypeTag, Uint1 } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+class ExternalCall extends Instruction {
+    indirect;
+    gasOffset;
+    addrOffset;
+    argsOffset;
+    argsSizeOffset;
+    successOffset;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, gasOffset, addrOffset, argsOffset, argsSizeOffset, successOffset){
+        super(), this.indirect = indirect, this.gasOffset = gasOffset, this.addrOffset = addrOffset, this.argsOffset = argsOffset, this.argsSizeOffset = argsSizeOffset, this.successOffset = successOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.gasOffset,
+            this.addrOffset,
+            this.argsOffset,
+            this.argsSizeOffset,
+            this.successOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [gasOffset, addrOffset, argsOffset, argsSizeOffset, successOffset] = addressing.resolve(operands, memory);
+        memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
+        memory.checkTag(TypeTag.FIELD, addrOffset);
+        memory.checkTag(TypeTag.UINT32, argsSizeOffset);
+        const calldataSize = memory.get(argsSizeOffset).toNumber();
+        const calldata = memory.getSlice(argsOffset, calldataSize).map((f)=>f.toFr());
+        memory.checkTagsRange(TypeTag.FIELD, argsOffset, calldataSize);
+        const callAddress = memory.getAs(addrOffset);
+        // If we are already in a static call, we propagate the environment.
+        const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
+        // First we consume the gas for this operation.
+        context.machineState.consumeGas(this.gasCost(calldataSize));
+        // Then we consume the gas allocated for the nested call. The excess will be refunded later.
+        // Gas allocation is capped by the amount of gas left in the current context.
+        // We have to do some dancing here because the gas allocation is a field,
+        // but in the machine state we track gas as a number.
+        const allocatedL2Gas = Number(BigIntMin(memory.get(gasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)));
+        const allocatedDaGas = Number(BigIntMin(memory.get(gasOffset + 1).toBigInt(), BigInt(context.machineState.daGasLeft)));
+        const allocatedGas = {
+            l2Gas: allocatedL2Gas,
+            daGas: allocatedDaGas
+        };
+        context.machineState.consumeGas(allocatedGas);
+        const aztecAddress = callAddress.toAztecAddress();
+        const nestedContext = await context.createNestedContractCallContext(aztecAddress, calldata, allocatedGas, callType);
+        const simulator = await context.provideSimulator(nestedContext);
+        const nestedCallResults = await simulator.execute();
+        const success = !nestedCallResults.reverted;
+        // Save return/revert data for later.
+        const fullReturnData = nestedCallResults.output;
+        context.machineState.nestedReturndata = fullReturnData;
+        // If the nested call reverted, we try to save the reason and the revert data.
+        // This will be used by the caller to try to reconstruct the call stack.
+        // This is only a heuristic and may not always work. It is intended to work
+        // for the case where a nested call reverts and the caller always rethrows
+        // (in Noir code).
+        if (!success) {
+            context.machineState.collectedRevertInfo = {
+                revertDataRepresentative: fullReturnData,
+                recursiveRevertReason: nestedCallResults.revertReason
+            };
+        }
+        // Write our success flag into memory.
+        memory.set(successOffset, new Uint1(success ? 1 : 0));
+        // Refund unused gas
+        context.machineState.refundGas(nestedCallResults.gasLeft);
+        // Merge nested call's state and trace based on whether it succeeded.
+        if (success) {
+            await context.persistableState.merge(nestedContext.persistableState);
+        } else {
+            await context.persistableState.reject(nestedContext.persistableState);
+        }
+    }
+}
+export class Call extends ExternalCall {
+    static type = 'CALL';
+    static opcode = Opcode.CALL;
+    get type() {
+        return Call.type;
+    }
+}
+export class StaticCall extends ExternalCall {
+    static type = 'STATICCALL';
+    static opcode = Opcode.STATICCALL;
+    get type() {
+        return StaticCall.type;
+    }
+}
+export class Return extends Instruction {
+    indirect;
+    returnOffset;
+    returnSizeOffset;
+    static type = 'RETURN';
+    static opcode = Opcode.RETURN;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, returnOffset, returnSizeOffset){
+        super(), this.indirect = indirect, this.returnOffset = returnOffset, this.returnSizeOffset = returnSizeOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.returnOffset,
+            this.returnSizeOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [returnOffset, returnSizeOffset] = addressing.resolve(operands, memory);
+        memory.checkTag(TypeTag.UINT32, returnSizeOffset);
+        const returnSize = memory.get(returnSizeOffset).toNumber();
+        context.machineState.consumeGas(this.gasCost(returnSize));
+        const output = memory.getSlice(returnOffset, returnSize).map((word)=>word.toFr());
+        context.machineState.return(output);
+    }
+    handlesPC() {
+        return true;
+    }
+}
+export class Revert extends Instruction {
+    indirect;
+    returnOffset;
+    retSizeOffset;
+    static type = 'REVERT';
+    static opcode = Opcode.REVERT_8;
+    static wireFormat8 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8
+    ];
+    static wireFormat16 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, returnOffset, retSizeOffset){
+        super(), this.indirect = indirect, this.returnOffset = returnOffset, this.retSizeOffset = retSizeOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.returnOffset,
+            this.retSizeOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [returnOffset, retSizeOffset] = addressing.resolve(operands, memory);
+        memory.checkTag(TypeTag.UINT32, retSizeOffset);
+        const retSize = memory.get(retSizeOffset).toNumber();
+        context.machineState.consumeGas(this.gasCost(retSize));
+        const output = memory.getSlice(returnOffset, retSize).map((word)=>word.toFr());
+        context.machineState.revert(output);
+    }
+    // We don't want to increase the PC after reverting because it breaks messages.
+    // Maybe we can remove this once messages don't depend on PCs.
+    handlesPC() {
+        return true;
+    }
+}
+/** Returns the smaller of two bigints. */ function BigIntMin(a, b) {
+    return a < b ? a : b;
+}

package/dest/{avm → public/avm}/opcodes/hashing.d.ts

@@ -1,4 +1,4 @@
-import { type AvmContext } from '../avm_context.js';
+import type { AvmContext } from '../avm_context.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Instruction } from './instruction.js';
 export declare class Poseidon2 extends Instruction {

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashing.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/hashing.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,SAAU,SAAQ,WAAW;IAa5B,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,gBAAgB;IAAU,OAAO,CAAC,iBAAiB;IAZjG,MAAM,CAAC,IAAI,EAAE,MAAM,CAAe;IAClC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAoB;IAClD,MAAM,CAAC,QAAQ,CAAC,SAAS,KAAK;IAG9B,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAKvC;gBAEkB,QAAQ,EAAE,MAAM,EAAU,gBAAgB,EAAE,MAAM,EAAU,iBAAiB,EAAE,MAAM;IAI5F,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBzD;AAED,qBAAa,WAAY,SAAQ,WAAW;IAY9B,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,SAAS;IAAU,OAAO,CAAC,WAAW;IAXpF,MAAM,CAAC,IAAI,EAAE,MAAM,CAAiB;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAsB;IAGpD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAKvC;gBAEkB,QAAQ,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM,EAAU,WAAW,EAAE,MAAM;IAK/E,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAgBzD;AAED,qBAAa,iBAAkB,SAAQ,WAAW;IAc9C,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,YAAY;IAhBtB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAuB;IAC1C,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAA4B;IAG1D,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAMvC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM;IAKjB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAuBzD"}

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

@@ -0,0 +1,114 @@
+import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
+import { Field, TypeTag, Uint32, Uint64 } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+export class Poseidon2 extends Instruction {
+    indirect;
+    inputStateOffset;
+    outputStateOffset;
+    static type = 'POSEIDON2';
+    static opcode = Opcode.POSEIDON2;
+    static stateSize = 4;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, inputStateOffset, outputStateOffset){
+        super(), this.indirect = indirect, this.inputStateOffset = inputStateOffset, this.outputStateOffset = outputStateOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.inputStateOffset,
+            this.outputStateOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
+        const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
+        memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
+        const outputState = await poseidon2Permutation(inputState);
+        memory.setSlice(outputOffset, outputState.map((word)=>new Field(word)));
+    }
+}
+export class KeccakF1600 extends Instruction {
+    indirect;
+    dstOffset;
+    inputOffset;
+    static type = 'KECCAKF1600';
+    static opcode = Opcode.KECCAKF1600;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, dstOffset, inputOffset){
+        super(), this.indirect = indirect, this.dstOffset = dstOffset, this.inputOffset = inputOffset;
+    }
+    // pub fn keccakf1600(input: [u64; 25]) -> [u64; 25]
+    async execute(context) {
+        const inputSize = 25;
+        const memory = context.machineState.memory;
+        const operands = [
+            this.dstOffset,
+            this.inputOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
+        context.machineState.consumeGas(this.gasCost());
+        const stateData = memory.getSlice(inputOffset, inputSize).map((word)=>word.toBigInt());
+        memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
+        const updatedState = keccakf1600(stateData);
+        const res = updatedState.map((word)=>new Uint64(word));
+        memory.setSlice(dstOffset, res);
+    }
+}
+export class Sha256Compression extends Instruction {
+    indirect;
+    outputOffset;
+    stateOffset;
+    inputsOffset;
+    static type = 'SHA256COMPRESSION';
+    static opcode = Opcode.SHA256COMPRESSION;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, outputOffset, stateOffset, inputsOffset){
+        super(), this.indirect = indirect, this.outputOffset = outputOffset, this.stateOffset = stateOffset, this.inputsOffset = inputsOffset;
+    }
+    async execute(context) {
+        const STATE_SIZE = 8;
+        const INPUTS_SIZE = 16;
+        const memory = context.machineState.memory;
+        const operands = [
+            this.outputOffset,
+            this.stateOffset,
+            this.inputsOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
+        // Note: size of output is same as size of state
+        context.machineState.consumeGas(this.gasCost());
+        const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map((word)=>word.toNumber()));
+        const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map((word)=>word.toNumber()));
+        memory.checkTagsRange(TypeTag.UINT32, inputsOffset, INPUTS_SIZE);
+        memory.checkTagsRange(TypeTag.UINT32, stateOffset, STATE_SIZE);
+        const output = sha256Compression(state, inputs);
+        // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)
+        const res = [
+            ...output
+        ].map((word)=>new Uint32(word));
+        memory.setSlice(outputOffset, res);
+    }
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dest/{avm → public/avm}/opcodes/instruction.d.ts

@@ -2,8 +2,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { AvmContext } from '../avm_context.js';
 import { type Gas } from '../avm_gas.js';
-import { type BufferCursor } from '../serialization/buffer_cursor.js';
-import { type Serializable } from '../serialization/bytecode_serialization.js';
+import type { BufferCursor } from '../serialization/buffer_cursor.js';
+import type { Serializable } from '../serialization/bytecode_serialization.js';
 import { Opcode, type OperandType } from '../serialization/instruction_serialization.js';
 type InstructionConstructor = {
     new (...args: any[]): Instruction;

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

@@ -0,0 +1 @@
+{"version":3,"file":"instruction.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/instruction.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,GAAG,EAAqD,MAAM,eAAe,CAAC;AAC5F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC/E,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAA4B,MAAM,+CAA+C,CAAC;AAEnH,KAAK,sBAAsB,GAAG;IAC5B,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW,CAAC;CACnC,CAAC;AAEF;;;GAGG;AACH,8BAAsB,WAAW;IAC/B;;;;OAIG;aACa,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAE3D;;OAEG;IACI,SAAS,IAAI,OAAO;IAI3B;;;;OAIG;IACI,QAAQ,IAAI,MAAM;WAUX,WAAW,CACvB,IAAI,EAAE,sBAAsB,GAAG;QAAE,UAAU,EAAE,WAAW,EAAE,CAAC;QAAC,EAAE,EAAE,GAAG,CAAA;KAAE,EACrE,GAAG,EAAE,YAAY,GAAG,MAAM,GACzB,WAAW;IAKP,SAAS,IAAI,MAAM;IAO1B;;;;;OAKG;IACI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,WAAW,GAAG,YAAY;IAShF;;;;;OAKG;WACW,EAAE,CAAC,IAAI,EAAE,sBAAsB,EAAE,UAAU,EAAE,WAAW,EAAE;2BAEjD,YAAY,GAAG,MAAM,KAAG,WAAW;;IAQ1D;;;OAGG;IACH,SAAS,CAAC,OAAO,CAAC,aAAa,GAAE,MAAU,GAAG,GAAG;IAMjD;;;OAGG;IACH,IAAW,IAAI,IAAI,MAAM,CAMxB;IAED;;;OAGG;IACH,IAAW,MAAM,IAAI,MAAM,CAM1B;CACF"}

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

@@ -0,0 +1,91 @@
+import { strict as assert } from 'assert';
+import { getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { Opcode, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
+/**
+ * Parent class for all AVM instructions.
+ * It's most important aspects are execute and (de)serialize.
+ */ export class Instruction {
+    /**
+   * Whether the instruction will modify the PC itself.
+   */ handlesPC() {
+        return false;
+    }
+    /**
+   * Generate a string representation of the instruction including
+   * the instruction sub-class name all of its flags and operands.
+   * @returns Thee string representation.
+   */ toString() {
+        let instructionStr = this.constructor.name + ': ';
+        // assumes that all properties are flags or operands
+        for (const prop of Object.getOwnPropertyNames(this)){
+            instructionStr += `${prop}:${this[prop].toString()}, `;
+        }
+        return instructionStr;
+    }
+    // Default deserialization which uses Class.opcode and Class.wireFormat.
+    static deserialize(buf) {
+        return this.as(this.wireFormat).deserialize(buf);
+    }
+    // Default serialization which uses Class.opcode and Class.wireFormat.
+    serialize() {
+        const klass = this.constructor;
+        assert(klass.opcode !== undefined && klass.opcode !== null);
+        assert(klass.wireFormat !== undefined && klass.wireFormat !== null);
+        return this.as(klass.opcode, klass.wireFormat).serialize();
+    }
+    /**
+   * Returns a new instruction instance that can be serialized with the given opcode and wire format.
+   * @param opcode The opcode of the instruction.
+   * @param wireFormat The wire format of the instruction.
+   * @returns The new instruction instance.
+   */ as(opcode, wireFormat) {
+        return Object.defineProperty(this, 'serialize', {
+            value: ()=>{
+                return serializeAs(wireFormat, opcode, this);
+            },
+            enumerable: false
+        });
+    }
+    /**
+   * Returns a new instruction class that can be deserialized with the given opcode and wire format.
+   * @param opcode The opcode of the instruction.
+   * @param wireFormat The wire format of the instruction.
+   * @returns The new instruction class.
+   */ static as(wireFormat) {
+        return Object.assign(this, {
+            deserialize: (buf)=>{
+                const res = deserialize(buf, wireFormat);
+                const args = res.slice(1); // Remove opcode.
+                return new this(...args);
+            }
+        });
+    }
+    /**
+   * Computes gas cost for the instruction based on its base cost and memory operations.
+   * @returns Gas cost.
+   */ gasCost(dynMultiplier = 0) {
+        const baseGasCost = getBaseGasCost(this.opcode);
+        const dynGasCost = mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
+        return sumGas(baseGasCost, dynGasCost);
+    }
+    /**
+   * Returns the stringified type of the instruction.
+   * Instruction sub-classes should have a static `type` property.
+   */ get type() {
+        const type = 'type' in this.constructor && this.constructor.type;
+        if (!type) {
+            throw new Error(`Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
+        }
+        return type;
+    }
+    /**
+   * Returns the opcode of the instruction.
+   * Instruction sub-classes should have a static `opcode` property.
+   */ get opcode() {
+        const opcode = 'opcode' in this.constructor ? this.constructor.opcode : undefined;
+        if (opcode === undefined || Opcode[opcode] === undefined) {
+            throw new Error(`Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`);
+        }
+        return opcode;
+    }
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"instruction_impl.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/instruction_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qFAAqF;AACrF,eAAO,MAAM,uBAAuB,eAMnC,CAAC;AACF,eAAO,MAAM,wBAAwB,eAMpC,CAAC;AAEF;;;GAGG;AACH,8BAAsB,uBAAwB,SAAQ,WAAW;IAK7D,SAAS,CAAC,QAAQ,EAAE,MAAM;IAC1B,SAAS,CAAC,OAAO,EAAE,MAAM;IACzB,SAAS,CAAC,OAAO,EAAE,MAAM;IACzB,SAAS,CAAC,SAAS,EAAE,MAAM;IAP7B,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,CAA2B;IACrE,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,WAAW,EAAE,CAA4B;gBAG3D,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM;CAI9B"}

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

@@ -0,0 +1,30 @@
+import { OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+/** Wire format that informs deserialization for instructions with three operands. */ export const ThreeOperandWireFormat8 = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT8
+];
+export const ThreeOperandWireFormat16 = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16
+];
+/**
+ * Covers (de)serialization for an instruction with:
+ * indirect, inTag, and three operands.
+ */ export class ThreeOperandInstruction extends Instruction {
+    indirect;
+    aOffset;
+    bOffset;
+    dstOffset;
+    static wireFormat8 = ThreeOperandWireFormat8;
+    static wireFormat16 = ThreeOperandWireFormat16;
+    constructor(indirect, aOffset, bOffset, dstOffset){
+        super(), this.indirect = indirect, this.aOffset = aOffset, this.bOffset = bOffset, this.dstOffset = dstOffset;
+    }
+}

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

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