@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.0208eb9

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

@@ -1,52 +1,55 @@
 import { TypeTag, Uint1 } from '../avm_memory_types.js';
+import { CallDataMemory, ReturnDataMemory } from '../calldata.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;
+    addressingMode;
+    l2GasOffset;
+    daGasOffset;
     addrOffset;
-    argsOffset;
     argsSizeOffset;
+    argsOffset;
     // Informs (de)serialization. See Instruction.deserialize.
     static wireFormat = [
         OperandType.UINT8,
-        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
         OperandType.UINT16,
         OperandType.UINT16,
         OperandType.UINT16,
         OperandType.UINT16
     ];
-    constructor(indirect, gasOffset, addrOffset, argsOffset, argsSizeOffset){
-        super(), this.indirect = indirect, this.gasOffset = gasOffset, this.addrOffset = addrOffset, this.argsOffset = argsOffset, this.argsSizeOffset = argsSizeOffset;
+    constructor(addressingMode, l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset){
+        super(), this.addressingMode = addressingMode, this.l2GasOffset = l2GasOffset, this.daGasOffset = daGasOffset, this.addrOffset = addrOffset, this.argsSizeOffset = argsSizeOffset, this.argsOffset = argsOffset;
     }
     async execute(context) {
         const memory = context.machineState.memory;
+        const addressing = Addressing.fromWire(this.addressingMode);
+        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
         const operands = [
-            this.gasOffset,
+            this.l2GasOffset,
+            this.daGasOffset,
             this.addrOffset,
-            this.argsOffset,
-            this.argsSizeOffset
+            this.argsSizeOffset,
+            this.argsOffset
         ];
-        const addressing = Addressing.fromWire(this.indirect, operands.length);
-        const [gasOffset, addrOffset, argsOffset, argsSizeOffset] = addressing.resolve(operands, memory);
-        memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
+        const [l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset] = addressing.resolve(operands, memory);
+        memory.checkTags(TypeTag.UINT32, l2GasOffset);
+        memory.checkTags(TypeTag.UINT32, daGasOffset);
         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 calldata = new CallDataMemory(memory, 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.
+        // 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 allocatedL2Gas = Number(BigIntMin(memory.get(l2GasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)));
+        const allocatedDaGas = Number(BigIntMin(memory.get(daGasOffset).toBigInt(), BigInt(context.machineState.daGasLeft)));
         const allocatedGas = {
             l2Gas: allocatedL2Gas,
             daGas: allocatedDaGas
@@ -58,10 +61,12 @@ class ExternalCall extends Instruction {
         const nestedCallResults = await simulator.execute();
         const success = !nestedCallResults.reverted;
         // Save return/revert data for later.
-        const fullReturnData = nestedCallResults.output;
-        context.machineState.nestedReturndata = fullReturnData;
+        const returnData = nestedCallResults.output;
+        context.machineState.nestedReturndata = returnData;
         // Track the success status directly
         context.machineState.nestedCallSuccess = success;
+        // Account for all instructions executed in the nested call
+        context.machineState.instrCounter += nestedCallResults.totalInstructions;
         // 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
@@ -69,7 +74,7 @@ class ExternalCall extends Instruction {
         // (in Noir code).
         if (!success) {
             context.machineState.collectedRevertInfo = {
-                revertDataRepresentative: fullReturnData,
+                revertDataRepresentative: returnData.bestEffortReadAll(),
                 recursiveRevertReason: nestedCallResults.revertReason
             };
         }
@@ -98,7 +103,7 @@ export class StaticCall extends ExternalCall {
     }
 }
 export class SuccessCopy extends Instruction {
-    indirect;
+    addressingMode;
     dstOffset;
     static type = 'SUCCESSCOPY';
     static opcode = Opcode.SUCCESSCOPY;
@@ -108,15 +113,16 @@ export class SuccessCopy extends Instruction {
         OperandType.UINT8,
         OperandType.UINT16
     ];
-    constructor(indirect, dstOffset){
-        super(), this.indirect = indirect, this.dstOffset = dstOffset;
+    constructor(addressingMode, dstOffset){
+        super(), this.addressingMode = addressingMode, this.dstOffset = dstOffset;
     }
     async execute(context) {
         const memory = context.machineState.memory;
+        const addressing = Addressing.fromWire(this.addressingMode);
+        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
         const operands = [
             this.dstOffset
         ];
-        const addressing = Addressing.fromWire(this.indirect, operands.length);
         const [dstOffset] = addressing.resolve(operands, memory);
         // Use the direct success tracking property
         const success = context.machineState.nestedCallSuccess;
@@ -125,9 +131,9 @@ export class SuccessCopy extends Instruction {
     }
 }
 export class Return extends Instruction {
-    indirect;
-    returnOffset;
+    addressingMode;
     returnSizeOffset;
+    returnOffset;
     static type = 'RETURN';
     static opcode = Opcode.RETURN;
     // Informs (de)serialization. See Instruction.deserialize.
@@ -137,21 +143,21 @@ export class Return extends Instruction {
         OperandType.UINT16,
         OperandType.UINT16
     ];
-    constructor(indirect, returnOffset, returnSizeOffset){
-        super(), this.indirect = indirect, this.returnOffset = returnOffset, this.returnSizeOffset = returnSizeOffset;
+    constructor(addressingMode, returnSizeOffset, returnOffset){
+        super(), this.addressingMode = addressingMode, this.returnSizeOffset = returnSizeOffset, this.returnOffset = returnOffset;
     }
     async execute(context) {
         const memory = context.machineState.memory;
+        const addressing = Addressing.fromWire(this.addressingMode);
+        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
         const operands = [
-            this.returnOffset,
-            this.returnSizeOffset
+            this.returnSizeOffset,
+            this.returnOffset
         ];
-        const addressing = Addressing.fromWire(this.indirect, operands.length);
-        const [returnOffset, returnSizeOffset] = addressing.resolve(operands, memory);
+        const [returnSizeOffset, returnOffset] = 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());
+        const output = new ReturnDataMemory(memory, returnOffset, returnSize);
         context.machineState.return(output);
     }
     handlesPC() {
@@ -159,9 +165,9 @@ export class Return extends Instruction {
     }
 }
 export class Revert extends Instruction {
-    indirect;
-    returnOffset;
+    addressingMode;
     retSizeOffset;
+    returnOffset;
     static type = 'REVERT';
     static opcode = Opcode.REVERT_8;
     static wireFormat8 = [
@@ -176,21 +182,21 @@ export class Revert extends Instruction {
         OperandType.UINT16,
         OperandType.UINT16
     ];
-    constructor(indirect, returnOffset, retSizeOffset){
-        super(), this.indirect = indirect, this.returnOffset = returnOffset, this.retSizeOffset = retSizeOffset;
+    constructor(addressingMode, retSizeOffset, returnOffset){
+        super(), this.addressingMode = addressingMode, this.retSizeOffset = retSizeOffset, this.returnOffset = returnOffset;
     }
     async execute(context) {
         const memory = context.machineState.memory;
+        const addressing = Addressing.fromWire(this.addressingMode);
+        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
         const operands = [
-            this.returnOffset,
-            this.retSizeOffset
+            this.retSizeOffset,
+            this.returnOffset
         ];
-        const addressing = Addressing.fromWire(this.indirect, operands.length);
-        const [returnOffset, retSizeOffset] = addressing.resolve(operands, memory);
+        const [retSizeOffset, returnOffset] = 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());
+        const output = new ReturnDataMemory(memory, returnOffset, retSize);
         context.machineState.revert(output);
     }
     // We don't want to increase the PC after reverting because it breaks messages.

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

@@ -2,35 +2,35 @@ 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 {
-    private indirect;
+    private addressingMode;
     private inputStateOffset;
     private outputStateOffset;
     static type: string;
     static readonly opcode: Opcode;
     static readonly stateSize = 4;
     static readonly wireFormat: OperandType[];
-    constructor(indirect: number, inputStateOffset: number, outputStateOffset: number);
+    constructor(addressingMode: number, inputStateOffset: number, outputStateOffset: number);
     execute(context: AvmContext): Promise<void>;
 }
 export declare class KeccakF1600 extends Instruction {
-    private indirect;
+    private addressingMode;
     private dstOffset;
     private inputOffset;
     static type: string;
     static readonly opcode: Opcode;
     static readonly wireFormat: OperandType[];
-    constructor(indirect: number, dstOffset: number, inputOffset: number);
+    constructor(addressingMode: number, dstOffset: number, inputOffset: number);
     execute(context: AvmContext): Promise<void>;
 }
 export declare class Sha256Compression extends Instruction {
-    private indirect;
+    private addressingMode;
     private outputOffset;
     private stateOffset;
     private inputsOffset;
     static type: string;
     static readonly opcode: Opcode;
     static readonly wireFormat: OperandType[];
-    constructor(indirect: number, outputOffset: number, stateOffset: number, inputsOffset: number);
+    constructor(addressingMode: number, outputOffset: number, stateOffset: number, inputsOffset: number);
     execute(context: AvmContext): Promise<void>;
 }
-//# sourceMappingURL=hashing.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzaGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3B1YmxpYy9hdm0vb3Bjb2Rlcy9oYXNoaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXBELE9BQU8sRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE1BQU0sK0NBQStDLENBQUM7QUFFcEYsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DLHFCQUFhLFNBQVUsU0FBUSxXQUFXO0lBY3RDLE9BQU8sQ0FBQyxjQUFjO0lBQ3RCLE9BQU8sQ0FBQyxnQkFBZ0I7SUFDeEIsT0FBTyxDQUFDLGlCQUFpQjtJQWYzQixNQUFNLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBZTtJQUNsQyxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQW9CO0lBQ2xELE1BQU0sQ0FBQyxRQUFRLENBQUMsU0FBUyxLQUFLO0lBRzlCLE1BQU0sQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFFLFdBQVcsRUFBRSxDQUt2QztJQUVGLFlBQ1UsY0FBYyxFQUFFLE1BQU0sRUFDdEIsZ0JBQWdCLEVBQUUsTUFBTSxFQUN4QixpQkFBaUIsRUFBRSxNQUFNLEVBR2xDO0lBRVksT0FBTyxDQUFDLE9BQU8sRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW9CdkQ7Q0FDRjtBQUVELHFCQUFhLFdBQVksU0FBUSxXQUFXO0lBYXhDLE9BQU8sQ0FBQyxjQUFjO0lBQ3RCLE9BQU8sQ0FBQyxTQUFTO0lBQ2pCLE9BQU8sQ0FBQyxXQUFXO0lBZHJCLE1BQU0sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFpQjtJQUNwQyxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQXNCO0lBR3BELE1BQU0sQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFFLFdBQVcsRUFBRSxDQUt2QztJQUVGLFlBQ1UsY0FBYyxFQUFFLE1BQU0sRUFDdEIsU0FBUyxFQUFFLE1BQU0sRUFDakIsV0FBVyxFQUFFLE1BQU0sRUFHNUI7SUFHWSxPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBbUJ2RDtDQUNGO0FBRUQscUJBQWEsaUJBQWtCLFNBQVEsV0FBVztJQWM5QyxPQUFPLENBQUMsY0FBYztJQUN0QixPQUFPLENBQUMsWUFBWTtJQUNwQixPQUFPLENBQUMsV0FBVztJQUNuQixPQUFPLENBQUMsWUFBWTtJQWhCdEIsTUFBTSxDQUFDLElBQUksRUFBRSxNQUFNLENBQXVCO0lBQzFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBNEI7SUFHMUQsTUFBTSxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsV0FBVyxFQUFFLENBTXZDO0lBRUYsWUFDVSxjQUFjLEVBQUUsTUFBTSxFQUN0QixZQUFZLEVBQUUsTUFBTSxFQUNwQixXQUFXLEVBQUUsTUFBTSxFQUNuQixZQUFZLEVBQUUsTUFBTSxFQUc3QjtJQUVZLE9BQU8sQ0FBQyxPQUFPLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E4QnZEO0NBQ0YifQ==

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

@@ -1 +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"}
+{"version":3,"file":"hashing.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/hashing.ts"],"names":[],"mappings":"AAIA,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;IActC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,iBAAiB;IAf3B,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;IAEF,YACU,cAAc,EAAE,MAAM,EACtB,gBAAgB,EAAE,MAAM,EACxB,iBAAiB,EAAE,MAAM,EAGlC;IAEY,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBvD;CACF;AAED,qBAAa,WAAY,SAAQ,WAAW;IAaxC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,WAAW;IAdrB,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;IAEF,YACU,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EAG5B;IAGY,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBvD;CACF;AAED,qBAAa,iBAAkB,SAAQ,WAAW;IAc9C,OAAO,CAAC,cAAc;IACtB,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;IAEF,YACU,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EAG7B;IAEY,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BvD;CACF"}

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

@@ -1,10 +1,12 @@
-import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
+import { keccakf1600 } from '@aztec/foundation/crypto/keccak';
+import { poseidon2Permutation } from '@aztec/foundation/crypto/poseidon';
+import { sha256Compression } from '@aztec/foundation/crypto/sha256';
 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;
+    addressingMode;
     inputStateOffset;
     outputStateOffset;
     static type = 'POSEIDON2';
@@ -17,17 +19,17 @@ export class Poseidon2 extends Instruction {
         OperandType.UINT16,
         OperandType.UINT16
     ];
-    constructor(indirect, inputStateOffset, outputStateOffset){
-        super(), this.indirect = indirect, this.inputStateOffset = inputStateOffset, this.outputStateOffset = outputStateOffset;
+    constructor(addressingMode, inputStateOffset, outputStateOffset){
+        super(), this.addressingMode = addressingMode, this.inputStateOffset = inputStateOffset, this.outputStateOffset = outputStateOffset;
     }
     async execute(context) {
         const memory = context.machineState.memory;
-        context.machineState.consumeGas(this.gasCost());
+        const addressing = Addressing.fromWire(this.addressingMode);
+        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
         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);
@@ -36,7 +38,7 @@ export class Poseidon2 extends Instruction {
     }
 }
 export class KeccakF1600 extends Instruction {
-    indirect;
+    addressingMode;
     dstOffset;
     inputOffset;
     static type = 'KECCAKF1600';
@@ -48,20 +50,20 @@ export class KeccakF1600 extends Instruction {
         OperandType.UINT16,
         OperandType.UINT16
     ];
-    constructor(indirect, dstOffset, inputOffset){
-        super(), this.indirect = indirect, this.dstOffset = dstOffset, this.inputOffset = inputOffset;
+    constructor(addressingMode, dstOffset, inputOffset){
+        super(), this.addressingMode = addressingMode, 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 addressing = Addressing.fromWire(this.addressingMode);
+        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
         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);
@@ -70,7 +72,7 @@ export class KeccakF1600 extends Instruction {
     }
 }
 export class Sha256Compression extends Instruction {
-    indirect;
+    addressingMode;
     outputOffset;
     stateOffset;
     inputsOffset;
@@ -84,27 +86,30 @@ export class Sha256Compression extends Instruction {
         OperandType.UINT16,
         OperandType.UINT16
     ];
-    constructor(indirect, outputOffset, stateOffset, inputsOffset){
-        super(), this.indirect = indirect, this.outputOffset = outputOffset, this.stateOffset = stateOffset, this.inputsOffset = inputsOffset;
+    constructor(addressingMode, outputOffset, stateOffset, inputsOffset){
+        super(), this.addressingMode = addressingMode, 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 addressing = Addressing.fromWire(this.addressingMode);
+        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
         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()));
+        const inputs = memory.getSlice(inputsOffset, INPUTS_SIZE).map((word)=>word.toBigInt());
+        const state = memory.getSlice(stateOffset, STATE_SIZE).map((word)=>word.toBigInt());
         memory.checkTagsRange(TypeTag.UINT32, inputsOffset, INPUTS_SIZE);
         memory.checkTagsRange(TypeTag.UINT32, stateOffset, STATE_SIZE);
-        const output = sha256Compression(state, inputs);
+        // At this point both state and inputs are Uint32Array-compatible
+        const inputsArray = new Uint32Array(inputs.map((i)=>Number(i)));
+        const stateArray = new Uint32Array(state.map((i)=>Number(i)));
+        const output = sha256Compression(stateArray, inputsArray);
         // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)
         const res = [
             ...output

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

@@ -13,4 +13,4 @@ export * from './environment_getters.js';
 export * from './accrued_substate.js';
 export * from './hashing.js';
 export * from './ec_add.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wdWJsaWMvYXZtL29wY29kZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsYUFBYSxDQUFDIn0=

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

@@ -1,9 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+import type { Bufferable } from '@aztec/foundation/serialize';
 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 { Opcode, type OperandType } from '../serialization/instruction_serialization.js';
 type InstructionConstructor = {
     new (...args: any[]): Instruction;
@@ -29,18 +27,18 @@ export declare abstract class Instruction {
      * @returns Thee string representation.
      */
     toString(): string;
-    static deserialize(this: InstructionConstructor & {
+    static fromBuffer(this: InstructionConstructor & {
         wireFormat: OperandType[];
         as: any;
     }, buf: BufferCursor | Buffer): Instruction;
-    serialize(): Buffer;
+    toBuffer(): Buffer;
     /**
      * 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: Opcode, wireFormat: OperandType[]): Instruction & Serializable;
+    as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Bufferable;
     /**
      * Returns a new instruction class that can be deserialized with the given opcode and wire format.
      * @param opcode The opcode of the instruction.
@@ -48,13 +46,19 @@ export declare abstract class Instruction {
      * @returns The new instruction class.
      */
     static as(this: InstructionConstructor, wireFormat: OperandType[]): InstructionConstructor & {
-        deserialize: (buf: BufferCursor | Buffer) => Instruction;
+        fromBuffer: (buf: Buffer<ArrayBufferLike> | BufferCursor) => Instruction;
     };
     /**
-     * Computes gas cost for the instruction based on its base cost and memory operations.
-     * @returns Gas cost.
+     * Returns the base gas cost for the instruction.
+     * @returns The base gas cost.
      */
-    protected gasCost(dynMultiplier?: number): Gas;
+    protected baseGasCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas;
+    /**
+     * Computes the dynamic gas cost for the instruction
+     * @param dynMultiplier - The multiplier for the dynamic gas cost.
+     * @returns The dynamic gas cost.
+     */
+    protected dynamicGasCost(dynMultiplier?: number): Gas;
     /**
      * Returns the stringified type of the instruction.
      * Instruction sub-classes should have a static `type` property.
@@ -67,4 +71,4 @@ export declare abstract class Instruction {
     get opcode(): Opcode;
 }
 export {};
-//# sourceMappingURL=instruction.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1Y3Rpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wdWJsaWMvYXZtL29wY29kZXMvaW5zdHJ1Y3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFJOUQsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssR0FBRyxFQUE0RSxNQUFNLGVBQWUsQ0FBQztBQUNuSCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUN0RSxPQUFPLEVBQUUsTUFBTSxFQUFFLEtBQUssV0FBVyxFQUE0QixNQUFNLCtDQUErQyxDQUFDO0FBRW5ILEtBQUssc0JBQXNCLEdBQUc7SUFDNUIsS0FBSyxHQUFHLElBQUksRUFBRSxHQUFHLEVBQUUsR0FBRyxXQUFXLENBQUM7Q0FDbkMsQ0FBQztBQUVGOzs7R0FHRztBQUNILDhCQUFzQixXQUFXO0lBQy9COzs7O09BSUc7SUFDSCxTQUFnQixPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7SUFFNUQ7O09BRUc7SUFDSSxTQUFTLElBQUksT0FBTyxDQUUxQjtJQUVEOzs7O09BSUc7SUFDSSxRQUFRLElBQUksTUFBTSxDQVN4QjtJQUdELE9BQWMsVUFBVSxDQUN0QixJQUFJLEVBQUUsc0JBQXNCLEdBQUc7UUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFFLENBQUM7UUFBQyxFQUFFLEVBQUUsR0FBRyxDQUFBO0tBQUUsRUFDckUsR0FBRyxFQUFFLFlBQVksR0FBRyxNQUFNLEdBQ3pCLFdBQVcsQ0FFYjtJQUdNLFFBQVEsSUFBSSxNQUFNLENBS3hCO0lBRUQ7Ozs7O09BS0c7SUFDSSxFQUFFLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFFLEdBQUcsV0FBVyxHQUFHLFVBQVUsQ0FPN0U7SUFFRDs7Ozs7T0FLRztJQUNILE9BQWMsRUFBRSxDQUFDLElBQUksRUFBRSxzQkFBc0IsRUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFFOztNQVF2RTtJQUVEOzs7T0FHRztJQUNILFNBQVMsQ0FBQyxXQUFXLENBQUMscUJBQXFCLEVBQUUsTUFBTSxFQUFFLHFCQUFxQixFQUFFLE1BQU0sR0FBRyxHQUFHLENBRXZGO0lBRUQ7Ozs7T0FJRztJQUNILFNBQVMsQ0FBQyxjQUFjLENBQUMsYUFBYSxHQUFFLE1BQVUsR0FBRyxHQUFHLENBRXZEO0lBRUQ7OztPQUdHO0lBQ0gsSUFBVyxJQUFJLElBQUksTUFBTSxDQUl4QjtJQUVEOzs7T0FHRztJQUNILElBQVcsTUFBTSxJQUFJLE1BQU0sQ0FRMUI7Q0FDRiJ9

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

@@ -1 +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"}
+{"version":3,"file":"instruction.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/instruction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAI9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,GAAG,EAA4E,MAAM,eAAe,CAAC;AACnH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,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;IACH,SAAgB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5D;;OAEG;IACI,SAAS,IAAI,OAAO,CAE1B;IAED;;;;OAIG;IACI,QAAQ,IAAI,MAAM,CASxB;IAGD,OAAc,UAAU,CACtB,IAAI,EAAE,sBAAsB,GAAG;QAAE,UAAU,EAAE,WAAW,EAAE,CAAC;QAAC,EAAE,EAAE,GAAG,CAAA;KAAE,EACrE,GAAG,EAAE,YAAY,GAAG,MAAM,GACzB,WAAW,CAEb;IAGM,QAAQ,IAAI,MAAM,CAKxB;IAED;;;;;OAKG;IACI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,WAAW,GAAG,UAAU,CAO7E;IAED;;;;;OAKG;IACH,OAAc,EAAE,CAAC,IAAI,EAAE,sBAAsB,EAAE,UAAU,EAAE,WAAW,EAAE;;MAQvE;IAED;;;OAGG;IACH,SAAS,CAAC,WAAW,CAAC,qBAAqB,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,GAAG,GAAG,CAEvF;IAED;;;;OAIG;IACH,SAAS,CAAC,cAAc,CAAC,aAAa,GAAE,MAAU,GAAG,GAAG,CAEvD;IAED;;;OAGG;IACH,IAAW,IAAI,IAAI,MAAM,CAIxB;IAED;;;OAGG;IACH,IAAW,MAAM,IAAI,MAAM,CAQ1B;CACF"}

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

@@ -1,5 +1,5 @@
 import { strict as assert } from 'assert';
-import { getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { computeAddressingCost, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import { Opcode, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
 /**
  * Parent class for all AVM instructions.
@@ -15,6 +15,8 @@ import { Opcode, deserialize, serializeAs } from '../serialization/instruction_s
    * the instruction sub-class name all of its flags and operands.
    * @returns Thee string representation.
    */ toString() {
+        // Note: we could have this be the actual wire opcode if `bytecode_serialization.ts` were to
+        // pass it into the class' static `Instruction.as(this, wireFormat)` method.
         let instructionStr = this.constructor.name + ': ';
         // assumes that all properties are flags or operands
         for (const prop of Object.getOwnPropertyNames(this)){
@@ -23,15 +25,15 @@ import { Opcode, deserialize, serializeAs } from '../serialization/instruction_s
         return instructionStr;
     }
     // Default deserialization which uses Class.opcode and Class.wireFormat.
-    static deserialize(buf) {
-        return this.as(this.wireFormat).deserialize(buf);
+    static fromBuffer(buf) {
+        return this.as(this.wireFormat).fromBuffer(buf);
     }
     // Default serialization which uses Class.opcode and Class.wireFormat.
-    serialize() {
+    toBuffer() {
         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();
+        return this.as(klass.opcode, klass.wireFormat).toBuffer();
     }
     /**
    * Returns a new instruction instance that can be serialized with the given opcode and wire format.
@@ -39,7 +41,7 @@ import { Opcode, deserialize, serializeAs } from '../serialization/instruction_s
    * @param wireFormat The wire format of the instruction.
    * @returns The new instruction instance.
    */ as(opcode, wireFormat) {
-        return Object.defineProperty(this, 'serialize', {
+        return Object.defineProperty(this, 'toBuffer', {
             value: ()=>{
                 return serializeAs(wireFormat, opcode, this);
             },
@@ -53,7 +55,7 @@ import { Opcode, deserialize, serializeAs } from '../serialization/instruction_s
    * @returns The new instruction class.
    */ static as(wireFormat) {
         return Object.assign(this, {
-            deserialize: (buf)=>{
+            fromBuffer: (buf)=>{
                 const res = deserialize(buf, wireFormat);
                 const args = res.slice(1); // Remove opcode.
                 return new this(...args);
@@ -61,21 +63,24 @@ import { Opcode, deserialize, serializeAs } from '../serialization/instruction_s
         });
     }
     /**
-   * 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 base gas cost for the instruction.
+   * @returns The base gas cost.
+   */ baseGasCost(indirectOperandsCount, relativeOperandsCount) {
+        return sumGas(getBaseGasCost(this.opcode), computeAddressingCost(indirectOperandsCount, relativeOperandsCount));
+    }
+    /**
+   * Computes the dynamic gas cost for the instruction
+   * @param dynMultiplier - The multiplier for the dynamic gas cost.
+   * @returns The dynamic gas cost.
+   */ dynamicGasCost(dynMultiplier = 0) {
+        return mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
     }
     /**
    * 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.`);
-        }
+        assert(!!type, `Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
         return type;
     }
     /**
@@ -83,9 +88,8 @@ import { Opcode, deserialize, serializeAs } from '../serialization/instruction_s
    * 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.`);
-        }
+        assert(opcode !== undefined, `Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`);
+        assert(Opcode[opcode] !== undefined, `Invalid opcode ${opcode} for instruction class ${this.constructor.name}.`);
         return opcode;
     }
 }

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

@@ -5,15 +5,15 @@ export declare const ThreeOperandWireFormat8: OperandType[];
 export declare const ThreeOperandWireFormat16: OperandType[];
 /**
  * Covers (de)serialization for an instruction with:
- * indirect, inTag, and three operands.
+ * addressing mode, inTag, and three operands.
  */
 export declare abstract class ThreeOperandInstruction extends Instruction {
-    protected indirect: number;
+    protected addressingMode: number;
     protected aOffset: number;
     protected bOffset: number;
     protected dstOffset: number;
     static readonly wireFormat8: OperandType[];
     static readonly wireFormat16: OperandType[];
-    constructor(indirect: number, aOffset: number, bOffset: number, dstOffset: number);
+    constructor(addressingMode: number, aOffset: number, bOffset: number, dstOffset: number);
 }
-//# sourceMappingURL=instruction_impl.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1Y3Rpb25faW1wbC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3B1YmxpYy9hdm0vb3Bjb2Rlcy9pbnN0cnVjdGlvbl9pbXBsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUM1RSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFL0MscUZBQXFGO0FBQ3JGLGVBQU8sTUFBTSx1QkFBdUIsZUFNbkMsQ0FBQztBQUNGLGVBQU8sTUFBTSx3QkFBd0IsZUFNcEMsQ0FBQztBQUVGOzs7R0FHRztBQUNILDhCQUFzQix1QkFBd0IsU0FBUSxXQUFXO0lBSzdELFNBQVMsQ0FBQyxjQUFjLEVBQUUsTUFBTTtJQUNoQyxTQUFTLENBQUMsT0FBTyxFQUFFLE1BQU07SUFDekIsU0FBUyxDQUFDLE9BQU8sRUFBRSxNQUFNO0lBQ3pCLFNBQVMsQ0FBQyxTQUFTLEVBQUUsTUFBTTtJQVA3QixNQUFNLENBQUMsUUFBUSxDQUFDLFdBQVcsRUFBRSxXQUFXLEVBQUUsQ0FBMkI7SUFDckUsTUFBTSxDQUFDLFFBQVEsQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLENBQTRCO0lBRXZFLFlBQ1ksY0FBYyxFQUFFLE1BQU0sRUFDdEIsT0FBTyxFQUFFLE1BQU0sRUFDZixPQUFPLEVBQUUsTUFBTSxFQUNmLFNBQVMsRUFBRSxNQUFNLEVBRzVCO0NBQ0YifQ==

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

@@ -1 +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"}
+{"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,cAAc,EAAE,MAAM;IAChC,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;IAEvE,YACY,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EAG5B;CACF"}

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

@@ -16,15 +16,15 @@ export const ThreeOperandWireFormat16 = [
 ];
 /**
  * Covers (de)serialization for an instruction with:
- * indirect, inTag, and three operands.
+ * addressing mode, inTag, and three operands.
  */ export class ThreeOperandInstruction extends Instruction {
-    indirect;
+    addressingMode;
     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;
+    constructor(addressingMode, aOffset, bOffset, dstOffset){
+        super(), this.addressingMode = addressingMode, this.aOffset = aOffset, this.bOffset = bOffset, this.dstOffset = dstOffset;
     }
 }