@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.0b941701

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

@@ -3,10 +3,12 @@ import { StaticCallAlterationError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
-class BaseStorageInstruction extends Instruction {
-    indirect;
-    aOffset;
-    bOffset;
+export class SStore extends Instruction {
+    addressingMode;
+    srcOffset;
+    slotOffset;
+    static type = 'SSTORE';
+    static opcode = Opcode.SSTORE;
     // Informs (de)serialization. See Instruction.deserialize.
     static wireFormat = [
         OperandType.UINT8,
@@ -14,53 +16,63 @@ class BaseStorageInstruction extends Instruction {
         OperandType.UINT16,
         OperandType.UINT16
     ];
-    constructor(indirect, aOffset, bOffset){
-        super(), this.indirect = indirect, this.aOffset = aOffset, this.bOffset = bOffset;
-    }
-}
-export class SStore extends BaseStorageInstruction {
-    static type = 'SSTORE';
-    static opcode = Opcode.SSTORE;
-    constructor(indirect, srcOffset, slotOffset){
-        super(indirect, srcOffset, slotOffset);
+    constructor(addressingMode, srcOffset, slotOffset){
+        super(), this.addressingMode = addressingMode, this.srcOffset = srcOffset, this.slotOffset = slotOffset;
     }
     async execute(context) {
         if (context.environment.isStaticCall) {
             throw new StaticCallAlterationError();
         }
         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.aOffset,
-            this.bOffset
+            this.srcOffset,
+            this.slotOffset
         ];
-        const addressing = Addressing.fromWire(this.indirect, operands.length);
         const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
+        // We read before tag checking since it's needed for gas cost calculation
+        const slot = memory.get(slotOffset).toFr();
+        context.machineState.consumeGas(this.dynamicGasCost(Number(context.persistableState.isStorageCold(context.environment.address, slot))));
         memory.checkTag(TypeTag.FIELD, slotOffset);
         memory.checkTag(TypeTag.FIELD, srcOffset);
-        const slot = memory.get(slotOffset).toFr();
         const value = memory.get(srcOffset).toFr();
         await context.persistableState.writeStorage(context.environment.address, slot, value);
     }
 }
-export class SLoad extends BaseStorageInstruction {
+export class SLoad extends Instruction {
+    addressingMode;
+    slotOffset;
+    contractAddressOffset;
+    dstOffset;
     static type = 'SLOAD';
     static opcode = Opcode.SLOAD;
-    constructor(indirect, slotOffset, dstOffset){
-        super(indirect, slotOffset, dstOffset);
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(addressingMode, slotOffset, contractAddressOffset, dstOffset){
+        super(), this.addressingMode = addressingMode, this.slotOffset = slotOffset, this.contractAddressOffset = contractAddressOffset, this.dstOffset = dstOffset;
     }
     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.aOffset,
-            this.bOffset
+            this.slotOffset,
+            this.contractAddressOffset,
+            this.dstOffset
         ];
-        const addressing = Addressing.fromWire(this.indirect, operands.length);
-        const [slotOffset, dstOffset] = addressing.resolve(operands, memory);
+        const [slotOffset, contractAddressOffset, dstOffset] = addressing.resolve(operands, memory);
         memory.checkTag(TypeTag.FIELD, slotOffset);
+        memory.checkTag(TypeTag.FIELD, contractAddressOffset);
         const slot = memory.get(slotOffset).toFr();
-        const value = await context.persistableState.readStorage(context.environment.address, slot);
+        const contractAddress = memory.get(contractAddressOffset).toAztecAddress();
+        const value = await context.persistableState.readStorage(contractAddress, slot);
         memory.set(dstOffset, new Field(value));
     }
 }

package/dest/public/avm/revert_reason.d.ts

@@ -0,0 +1,18 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AvmContext } from './avm_context.js';
+import { type AvmExecutionError, AvmRevertReason } from './errors.js';
+/**
+ * Create a "revert reason" error for an exceptional halt.
+ *
+ * @param haltingError - the lower-level error causing the exceptional halt
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export declare function revertReasonFromExceptionalHalt(haltingError: AvmExecutionError, context: AvmContext): Promise<AvmRevertReason>;
+/**
+ * Create a "revert reason" error for an explicit revert (a root cause).
+ *
+ * @param revertData - output data of the explicit REVERT instruction
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export declare function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): Promise<AvmRevertReason>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV2ZXJ0X3JlYXNvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9hdm0vcmV2ZXJ0X3JlYXNvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUV6RCxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFpQ3RFOzs7OztHQUtHO0FBQ0gsd0JBQXNCLCtCQUErQixDQUNuRCxZQUFZLEVBQUUsaUJBQWlCLEVBQy9CLE9BQU8sRUFBRSxVQUFVLEdBQ2xCLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FFMUI7QUFFRDs7Ozs7R0FLRztBQUNILHdCQUFzQiw4QkFBOEIsQ0FBQyxVQUFVLEVBQUUsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsZUFBZSxDQUFDLENBRXBIIn0=

package/dest/public/avm/revert_reason.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revert_reason.d.ts","sourceRoot":"","sources":["../../../src/public/avm/revert_reason.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,KAAK,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAiCtE;;;;;GAKG;AACH,wBAAsB,+BAA+B,CACnD,YAAY,EAAE,iBAAiB,EAC/B,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,eAAe,CAAC,CAE1B;AAED;;;;;GAKG;AACH,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,CAEpH"}

package/dest/public/avm/revert_reason.js

@@ -0,0 +1,39 @@
+import { AvmRevertReason } from './errors.js';
+async function createRevertReason(message, revertData, context) {
+    // We drop the returnPc information.
+    const internalCallStack = context.machineState.internalCallStack.map((entry)=>entry.callPc);
+    // If we are reverting due to the same error that we have been tracking, we use the nested error as the cause.
+    let nestedError = undefined;
+    const revertDataEquals = (a, b)=>a.length === b.length && a.every((v, i)=>v.equals(b[i]));
+    if (context.machineState.collectedRevertInfo && revertDataEquals(context.machineState.collectedRevertInfo.revertDataRepresentative, revertData)) {
+        nestedError = context.machineState.collectedRevertInfo.recursiveRevertReason;
+        message = context.machineState.collectedRevertInfo.recursiveRevertReason.message;
+    }
+    const { functionSelector, functionName } = await context.persistableState.getPublicFunctionSelectorAndName(context.environment);
+    return new AvmRevertReason(message, /*failingFunction=*/ {
+        contractAddress: context.environment.address,
+        functionSelector,
+        functionName
+    }, /*noirCallStack=*/ [
+        ...internalCallStack,
+        context.machineState.pc
+    ].map((pc)=>`0.${pc}`), /*options=*/ {
+        cause: nestedError
+    });
+}
+/**
+ * Create a "revert reason" error for an exceptional halt.
+ *
+ * @param haltingError - the lower-level error causing the exceptional halt
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */ export async function revertReasonFromExceptionalHalt(haltingError, context) {
+    return await createRevertReason(haltingError.message, [], context);
+}
+/**
+ * Create a "revert reason" error for an explicit revert (a root cause).
+ *
+ * @param revertData - output data of the explicit REVERT instruction
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */ export async function revertReasonFromExplicitRevert(revertData, context) {
+    return await createRevertReason('Assertion failed: ', revertData, context);
+}

package/dest/public/avm/serialization/buffer_cursor.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 export declare class BufferCursor {
     private _buffer;
     private _position;
@@ -25,4 +23,4 @@ export declare class BufferCursor {
     writeBigInt64LE(v: bigint): number;
     writeBigInt64BE(v: bigint): number;
 }
-//# sourceMappingURL=buffer_cursor.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVmZmVyX2N1cnNvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3B1YmxpYy9hdm0vc2VyaWFsaXphdGlvbi9idWZmZXJfY3Vyc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLHFCQUFhLFlBQVk7SUFFckIsT0FBTyxDQUFDLE9BQU87SUFDZixPQUFPLENBQUMsU0FBUztJQUZuQixZQUNVLE9BQU8sRUFBRSxNQUFNLEVBQ2YsU0FBUyxHQUFFLE1BQVUsRUFDM0I7SUFFRyxRQUFRLElBQUksTUFBTSxDQUV4QjtJQUVNLE1BQU0sSUFBSSxNQUFNLENBRXRCO0lBRU0sR0FBRyxJQUFJLE9BQU8sQ0FFcEI7SUFFTSxnQkFBZ0IsSUFBSSxNQUFNLENBRWhDO0lBRU0sT0FBTyxDQUFDLENBQUMsRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUU5QjtJQUVNLFNBQVMsSUFBSSxNQUFNLENBR3pCO0lBRU0sU0FBUyxJQUFJLE1BQU0sQ0FJekI7SUFFTSxZQUFZLElBQUksTUFBTSxDQUk1QjtJQUVNLFlBQVksSUFBSSxNQUFNLENBSTVCO0lBRU0sWUFBWSxJQUFJLE1BQU0sQ0FJNUI7SUFFTSxZQUFZLElBQUksTUFBTSxDQUk1QjtJQUVNLGNBQWMsSUFBSSxNQUFNLENBSTlCO0lBRU0sY0FBYyxJQUFJLE1BQU0sQ0FJOUI7SUFFTSxVQUFVLENBQUMsQ0FBQyxFQUFFLE1BQU0sVUFJMUI7SUFFTSxhQUFhLENBQUMsQ0FBQyxFQUFFLE1BQU0sVUFJN0I7SUFFTSxhQUFhLENBQUMsQ0FBQyxFQUFFLE1BQU0sVUFJN0I7SUFFTSxhQUFhLENBQUMsQ0FBQyxFQUFFLE1BQU0sVUFJN0I7SUFFTSxhQUFhLENBQUMsQ0FBQyxFQUFFLE1BQU0sVUFJN0I7SUFFTSxlQUFlLENBQUMsQ0FBQyxFQUFFLE1BQU0sVUFJL0I7SUFFTSxlQUFlLENBQUMsQ0FBQyxFQUFFLE1BQU0sVUFJL0I7Q0FDRiJ9

package/dest/public/avm/serialization/buffer_cursor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_cursor.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/serialization/buffer_cursor.ts"],"names":[],"mappings":";;AAGA,qBAAa,YAAY;IACX,OAAO,CAAC,OAAO;IAAU,OAAO,CAAC,SAAS;gBAAlC,OAAO,EAAE,MAAM,EAAU,SAAS,GAAE,MAAU;IAE3D,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,MAAM;IAIhB,GAAG,IAAI,OAAO;IAId,gBAAgB,IAAI,MAAM;IAI1B,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIxB,SAAS,IAAI,MAAM;IAKnB,SAAS,IAAI,MAAM;IAMnB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,cAAc,IAAI,MAAM;IAMxB,cAAc,IAAI,MAAM;IAMxB,UAAU,CAAC,CAAC,EAAE,MAAM;IAMpB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,eAAe,CAAC,CAAC,EAAE,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,MAAM;CAKjC"}
+{"version":3,"file":"buffer_cursor.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/serialization/buffer_cursor.ts"],"names":[],"mappings":"AAGA,qBAAa,YAAY;IAErB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,SAAS;IAFnB,YACU,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,MAAU,EAC3B;IAEG,QAAQ,IAAI,MAAM,CAExB;IAEM,MAAM,IAAI,MAAM,CAEtB;IAEM,GAAG,IAAI,OAAO,CAEpB;IAEM,gBAAgB,IAAI,MAAM,CAEhC;IAEM,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAE9B;IAEM,SAAS,IAAI,MAAM,CAGzB;IAEM,SAAS,IAAI,MAAM,CAIzB;IAEM,YAAY,IAAI,MAAM,CAI5B;IAEM,YAAY,IAAI,MAAM,CAI5B;IAEM,YAAY,IAAI,MAAM,CAI5B;IAEM,YAAY,IAAI,MAAM,CAI5B;IAEM,cAAc,IAAI,MAAM,CAI9B;IAEM,cAAc,IAAI,MAAM,CAI9B;IAEM,UAAU,CAAC,CAAC,EAAE,MAAM,UAI1B;IAEM,aAAa,CAAC,CAAC,EAAE,MAAM,UAI7B;IAEM,aAAa,CAAC,CAAC,EAAE,MAAM,UAI7B;IAEM,aAAa,CAAC,CAAC,EAAE,MAAM,UAI7B;IAEM,aAAa,CAAC,CAAC,EAAE,MAAM,UAI7B;IAEM,eAAe,CAAC,CAAC,EAAE,MAAM,UAI/B;IAEM,eAAe,CAAC,CAAC,EAAE,MAAM,UAI/B;CACF"}

package/dest/public/avm/serialization/bytecode_serialization.d.ts

@@ -1,12 +1,8 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+import { type Bufferable } from '@aztec/foundation/serialize';
 import { Instruction } from '../opcodes/index.js';
 import { BufferCursor } from './buffer_cursor.js';
 import { Opcode } from './instruction_serialization.js';
 export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
-export interface Serializable {
-    serialize(): Buffer;
-}
 export interface Deserializable {
     deserialize: InstructionDeserializer;
 }
@@ -15,7 +11,7 @@ export declare const INSTRUCTION_SET: Map<Opcode, InstructionDeserializer>;
 /**
  * Serializes an array of instructions to bytecode.
  */
-export declare function encodeToBytecode(instructions: Serializable[]): Buffer;
+export declare function encodeToBytecode(instructions: Bufferable[]): Buffer;
 export declare function decodeFromBytecode(bytecode: Buffer, instructionSet?: InstructionSet): Instruction[];
 export declare function decodeInstructionFromBytecode(bytecode: Buffer, pc: number, instructionSet?: InstructionSet): [Instruction, number];
-//# sourceMappingURL=bytecode_serialization.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnl0ZWNvZGVfc2VyaWFsaXphdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3B1YmxpYy9hdm0vc2VyaWFsaXphdGlvbi9ieXRlY29kZV9zZXJpYWxpemF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLFVBQVUsRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQVVqRixPQUFPLEVBZ0JMLFdBQVcsRUFnQ1osTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFvQixNQUFNLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUUxRSxNQUFNLE1BQU0sdUJBQXVCLEdBQUcsQ0FBQyxHQUFHLEVBQUUsWUFBWSxHQUFHLE1BQU0sS0FBSyxXQUFXLENBQUM7QUFFbEYsTUFBTSxXQUFXLGNBQWM7SUFDN0IsV0FBVyxFQUFFLHVCQUF1QixDQUFDO0NBQ3RDO0FBRUQsTUFBTSxNQUFNLGNBQWMsR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLHVCQUF1QixDQUFDLENBQUM7QUFDbEUsZUFBTyxNQUFNLGVBQWUsc0NBb0YxQixDQUFDO0FBRUg7O0dBRUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLENBQUMsWUFBWSxFQUFFLFVBQVUsRUFBRSxHQUFHLE1BQU0sQ0FFbkU7QUFHRCx3QkFBZ0Isa0JBQWtCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxjQUFjLEdBQUUsY0FBZ0MsR0FBRyxXQUFXLEVBQUUsQ0FTcEg7QUFHRCx3QkFBZ0IsNkJBQTZCLENBQzNDLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLEVBQUUsRUFBRSxNQUFNLEVBQ1YsY0FBYyxHQUFFLGNBQWdDLEdBQy9DLENBQUMsV0FBVyxFQUFFLE1BQU0sQ0FBQyxDQW1DdkIifQ==

package/dest/public/avm/serialization/bytecode_serialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bytecode_serialization.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/serialization/bytecode_serialization.ts"],"names":[],"mappings":";;AACA,OAAO,EAgBL,WAAW,EAgCZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAoB,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAE1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,KAAK,WAAW,CAAC;AAElF,MAAM,WAAW,YAAY;IAC3B,SAAS,IAAI,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,uBAAuB,CAAC;CACtC;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAClE,eAAO,MAAM,eAAe,sCAoF1B,CAAC;AAEH;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,MAAM,CAErE;AAGD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,GAAE,cAAgC,GAAG,WAAW,EAAE,CASpH;AAGD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,EACV,cAAc,GAAE,cAAgC,GAC/C,CAAC,WAAW,EAAE,MAAM,CAAC,CA+BvB"}
+{"version":3,"file":"bytecode_serialization.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/serialization/bytecode_serialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,6BAA6B,CAAC;AAUjF,OAAO,EAgBL,WAAW,EAgCZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAoB,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAE1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,KAAK,WAAW,CAAC;AAElF,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,uBAAuB,CAAC;CACtC;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAClE,eAAO,MAAM,eAAe,sCAoF1B,CAAC;AAEH;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,UAAU,EAAE,GAAG,MAAM,CAEnE;AAGD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,GAAE,cAAgC,GAAG,WAAW,EAAE,CASpH;AAGD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,EACV,cAAc,GAAE,cAAgC,GAC/C,CAAC,WAAW,EAAE,MAAM,CAAC,CAmCvB"}

package/dest/public/avm/serialization/bytecode_serialization.js

@@ -1,293 +1,294 @@
-import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError } from '../errors.js';
+import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError, InvalidTagValueError, duringInstrFetch } from '../errors.js';
 import { Add, And, Call, CalldataCopy, Cast, DebugLog, Div, EcAdd, EmitNoteHash, EmitNullifier, EmitUnencryptedLog, Eq, FieldDiv, GetContractInstance, GetEnvVar, Instruction, InternalCall, InternalReturn, Jump, JumpI, KeccakF1600, L1ToL2MessageExists, Lt, Lte, Mov, Mul, Not, NoteHashExists, NullifierExists, Or, Poseidon2, Return, ReturndataCopy, ReturndataSize, Revert, SLoad, SStore, SendL2ToL1Message, Set, Sha256Compression, Shl, Shr, StaticCall, Sub, SuccessCopy, ToRadixBE, Xor } from '../opcodes/index.js';
 import { BufferCursor } from './buffer_cursor.js';
 import { MAX_OPCODE_VALUE, Opcode } from './instruction_serialization.js';
 export const INSTRUCTION_SET = new Map([
     [
         Opcode.ADD_8,
-        Add.as(Add.wireFormat8).deserialize
+        Add.as(Add.wireFormat8).fromBuffer
     ],
     [
         Opcode.ADD_16,
-        Add.as(Add.wireFormat16).deserialize
+        Add.as(Add.wireFormat16).fromBuffer
     ],
     [
         Opcode.SUB_8,
-        Sub.as(Sub.wireFormat8).deserialize
+        Sub.as(Sub.wireFormat8).fromBuffer
     ],
     [
         Opcode.SUB_16,
-        Sub.as(Sub.wireFormat16).deserialize
+        Sub.as(Sub.wireFormat16).fromBuffer
     ],
     [
         Opcode.MUL_8,
-        Mul.as(Mul.wireFormat8).deserialize
+        Mul.as(Mul.wireFormat8).fromBuffer
     ],
     [
         Opcode.MUL_16,
-        Mul.as(Mul.wireFormat16).deserialize
+        Mul.as(Mul.wireFormat16).fromBuffer
     ],
     [
         Opcode.DIV_8,
-        Div.as(Div.wireFormat8).deserialize
+        Div.as(Div.wireFormat8).fromBuffer
     ],
     [
         Opcode.DIV_16,
-        Div.as(Div.wireFormat16).deserialize
+        Div.as(Div.wireFormat16).fromBuffer
     ],
     [
         Opcode.FDIV_8,
-        FieldDiv.as(FieldDiv.wireFormat8).deserialize
+        FieldDiv.as(FieldDiv.wireFormat8).fromBuffer
     ],
     [
         Opcode.FDIV_16,
-        FieldDiv.as(FieldDiv.wireFormat16).deserialize
+        FieldDiv.as(FieldDiv.wireFormat16).fromBuffer
     ],
     [
         Opcode.EQ_8,
-        Eq.as(Eq.wireFormat8).deserialize
+        Eq.as(Eq.wireFormat8).fromBuffer
     ],
     [
         Opcode.EQ_16,
-        Eq.as(Eq.wireFormat16).deserialize
+        Eq.as(Eq.wireFormat16).fromBuffer
     ],
     [
         Opcode.LT_8,
-        Lt.as(Lt.wireFormat8).deserialize
+        Lt.as(Lt.wireFormat8).fromBuffer
     ],
     [
         Opcode.LT_16,
-        Lt.as(Lt.wireFormat16).deserialize
+        Lt.as(Lt.wireFormat16).fromBuffer
     ],
     [
         Opcode.LTE_8,
-        Lte.as(Lte.wireFormat8).deserialize
+        Lte.as(Lte.wireFormat8).fromBuffer
     ],
     [
         Opcode.LTE_16,
-        Lte.as(Lte.wireFormat16).deserialize
+        Lte.as(Lte.wireFormat16).fromBuffer
     ],
     [
         Opcode.AND_8,
-        And.as(And.wireFormat8).deserialize
+        And.as(And.wireFormat8).fromBuffer
     ],
     [
         Opcode.AND_16,
-        And.as(And.wireFormat16).deserialize
+        And.as(And.wireFormat16).fromBuffer
     ],
     [
         Opcode.OR_8,
-        Or.as(Or.wireFormat8).deserialize
+        Or.as(Or.wireFormat8).fromBuffer
     ],
     [
         Opcode.OR_16,
-        Or.as(Or.wireFormat16).deserialize
+        Or.as(Or.wireFormat16).fromBuffer
     ],
     [
         Opcode.XOR_8,
-        Xor.as(Xor.wireFormat8).deserialize
+        Xor.as(Xor.wireFormat8).fromBuffer
     ],
     [
         Opcode.XOR_16,
-        Xor.as(Xor.wireFormat16).deserialize
+        Xor.as(Xor.wireFormat16).fromBuffer
     ],
     [
         Opcode.NOT_8,
-        Not.as(Not.wireFormat8).deserialize
+        Not.as(Not.wireFormat8).fromBuffer
     ],
     [
         Opcode.NOT_16,
-        Not.as(Not.wireFormat16).deserialize
+        Not.as(Not.wireFormat16).fromBuffer
     ],
     [
         Opcode.SHL_8,
-        Shl.as(Shl.wireFormat8).deserialize
+        Shl.as(Shl.wireFormat8).fromBuffer
     ],
     [
         Opcode.SHL_16,
-        Shl.as(Shl.wireFormat16).deserialize
+        Shl.as(Shl.wireFormat16).fromBuffer
     ],
     [
         Opcode.SHR_8,
-        Shr.as(Shr.wireFormat8).deserialize
+        Shr.as(Shr.wireFormat8).fromBuffer
     ],
     [
         Opcode.SHR_16,
-        Shr.as(Shr.wireFormat16).deserialize
+        Shr.as(Shr.wireFormat16).fromBuffer
     ],
     [
         Opcode.CAST_8,
-        Cast.as(Cast.wireFormat8).deserialize
+        Cast.as(Cast.wireFormat8).fromBuffer
     ],
     [
         Opcode.CAST_16,
-        Cast.as(Cast.wireFormat16).deserialize
+        Cast.as(Cast.wireFormat16).fromBuffer
     ],
     // Execution Environment
     [
         Opcode.GETENVVAR_16,
-        GetEnvVar.as(GetEnvVar.wireFormat16).deserialize
+        GetEnvVar.as(GetEnvVar.wireFormat16).fromBuffer
     ],
     [
         CalldataCopy.opcode,
-        Instruction.deserialize.bind(CalldataCopy)
+        Instruction.fromBuffer.bind(CalldataCopy)
     ],
     [
         SuccessCopy.opcode,
-        Instruction.deserialize.bind(SuccessCopy)
+        Instruction.fromBuffer.bind(SuccessCopy)
     ],
     [
         Opcode.RETURNDATASIZE,
-        Instruction.deserialize.bind(ReturndataSize)
+        Instruction.fromBuffer.bind(ReturndataSize)
     ],
     [
         Opcode.RETURNDATACOPY,
-        Instruction.deserialize.bind(ReturndataCopy)
+        Instruction.fromBuffer.bind(ReturndataCopy)
     ],
     // Machine State - Internal Control Flow
     [
         Jump.opcode,
-        Instruction.deserialize.bind(Jump)
+        Instruction.fromBuffer.bind(Jump)
     ],
     [
         JumpI.opcode,
-        Instruction.deserialize.bind(JumpI)
+        Instruction.fromBuffer.bind(JumpI)
     ],
     [
         InternalCall.opcode,
-        Instruction.deserialize.bind(InternalCall)
+        Instruction.fromBuffer.bind(InternalCall)
     ],
     [
         InternalReturn.opcode,
-        Instruction.deserialize.bind(InternalReturn)
+        Instruction.fromBuffer.bind(InternalReturn)
     ],
     [
         Opcode.SET_8,
-        Set.as(Set.wireFormat8).deserialize
+        Set.as(Set.wireFormat8).fromBuffer
     ],
     [
         Opcode.SET_16,
-        Set.as(Set.wireFormat16).deserialize
+        Set.as(Set.wireFormat16).fromBuffer
     ],
     [
         Opcode.SET_32,
-        Set.as(Set.wireFormat32).deserialize
+        Set.as(Set.wireFormat32).fromBuffer
     ],
     [
         Opcode.SET_64,
-        Set.as(Set.wireFormat64).deserialize
+        Set.as(Set.wireFormat64).fromBuffer
     ],
     [
         Opcode.SET_128,
-        Set.as(Set.wireFormat128).deserialize
+        Set.as(Set.wireFormat128).fromBuffer
     ],
     [
         Opcode.SET_FF,
-        Set.as(Set.wireFormatFF).deserialize
+        Set.as(Set.wireFormatFF).fromBuffer
     ],
     [
         Opcode.MOV_8,
-        Mov.as(Mov.wireFormat8).deserialize
+        Mov.as(Mov.wireFormat8).fromBuffer
     ],
     [
         Opcode.MOV_16,
-        Mov.as(Mov.wireFormat16).deserialize
+        Mov.as(Mov.wireFormat16).fromBuffer
     ],
     // World State
     [
         SLoad.opcode,
-        Instruction.deserialize.bind(SLoad)
+        Instruction.fromBuffer.bind(SLoad)
     ],
     [
         SStore.opcode,
-        Instruction.deserialize.bind(SStore)
+        Instruction.fromBuffer.bind(SStore)
     ],
     [
         NoteHashExists.opcode,
-        Instruction.deserialize.bind(NoteHashExists)
+        Instruction.fromBuffer.bind(NoteHashExists)
     ],
     [
         EmitNoteHash.opcode,
-        Instruction.deserialize.bind(EmitNoteHash)
+        Instruction.fromBuffer.bind(EmitNoteHash)
     ],
     [
         NullifierExists.opcode,
-        Instruction.deserialize.bind(NullifierExists)
+        Instruction.fromBuffer.bind(NullifierExists)
     ],
     [
         EmitNullifier.opcode,
-        Instruction.deserialize.bind(EmitNullifier)
+        Instruction.fromBuffer.bind(EmitNullifier)
     ],
     [
         L1ToL2MessageExists.opcode,
-        Instruction.deserialize.bind(L1ToL2MessageExists)
+        Instruction.fromBuffer.bind(L1ToL2MessageExists)
     ],
     // Accrued Substate
     [
         EmitUnencryptedLog.opcode,
-        Instruction.deserialize.bind(EmitUnencryptedLog)
+        Instruction.fromBuffer.bind(EmitUnencryptedLog)
     ],
     [
         SendL2ToL1Message.opcode,
-        Instruction.deserialize.bind(SendL2ToL1Message)
+        Instruction.fromBuffer.bind(SendL2ToL1Message)
     ],
     [
         GetContractInstance.opcode,
-        Instruction.deserialize.bind(GetContractInstance)
+        Instruction.fromBuffer.bind(GetContractInstance)
     ],
     // Control Flow - Contract Calls
     [
         Call.opcode,
-        Instruction.deserialize.bind(Call)
+        Instruction.fromBuffer.bind(Call)
     ],
     [
         StaticCall.opcode,
-        Instruction.deserialize.bind(StaticCall)
+        Instruction.fromBuffer.bind(StaticCall)
     ],
     [
         Return.opcode,
-        Instruction.deserialize.bind(Return)
+        Instruction.fromBuffer.bind(Return)
     ],
     [
         Opcode.REVERT_8,
-        Revert.as(Revert.wireFormat8).deserialize
+        Revert.as(Revert.wireFormat8).fromBuffer
     ],
     [
         Opcode.REVERT_16,
-        Revert.as(Revert.wireFormat16).deserialize
+        Revert.as(Revert.wireFormat16).fromBuffer
     ],
     // Misc
     [
         DebugLog.opcode,
-        Instruction.deserialize.bind(DebugLog)
+        Instruction.fromBuffer.bind(DebugLog)
     ],
     // Gadgets
     [
         EcAdd.opcode,
-        Instruction.deserialize.bind(EcAdd)
+        Instruction.fromBuffer.bind(EcAdd)
     ],
     [
         Poseidon2.opcode,
-        Instruction.deserialize.bind(Poseidon2)
+        Instruction.fromBuffer.bind(Poseidon2)
     ],
     [
         Sha256Compression.opcode,
-        Instruction.deserialize.bind(Sha256Compression)
+        Instruction.fromBuffer.bind(Sha256Compression)
     ],
     [
         KeccakF1600.opcode,
-        Instruction.deserialize.bind(KeccakF1600)
+        Instruction.fromBuffer.bind(KeccakF1600)
     ],
     // Conversions
     [
         ToRadixBE.opcode,
-        Instruction.deserialize.bind(ToRadixBE)
+        Instruction.fromBuffer.bind(ToRadixBE)
     ]
 ]);
 /**
  * Serializes an array of instructions to bytecode.
  */ export function encodeToBytecode(instructions) {
-    return Buffer.concat(instructions.map((i)=>i.serialize()));
+    return serializeToBuffer(instructions);
 }
 // For testing only
 export function decodeFromBytecode(bytecode, instructionSet = INSTRUCTION_SET) {
@@ -303,14 +304,14 @@ export function decodeFromBytecode(bytecode, instructionSet = INSTRUCTION_SET) {
 // Returns the instruction and the number of bytes consumed.
 export function decodeInstructionFromBytecode(bytecode, pc, instructionSet = INSTRUCTION_SET) {
     if (pc >= bytecode.length) {
-        throw new InvalidProgramCounterError(pc, bytecode.length);
+        throw new InvalidProgramCounterError(pc, bytecode.length - 1);
     }
     try {
         const cursor = new BufferCursor(bytecode, pc);
         const startingPosition = cursor.position();
         const opcode = cursor.bufferAtPosition().readUint8(); // peek.
         if (opcode > MAX_OPCODE_VALUE) {
-            throw new InvalidOpcodeError(`Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes.`);
+            throw new InvalidOpcodeError(`Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes (at PC ${pc}).`);
         }
         const instructionDeserializerOrUndef = instructionSet.get(opcode);
         if (instructionDeserializerOrUndef === undefined) {
@@ -323,10 +324,13 @@ export function decodeInstructionFromBytecode(bytecode, pc, instructionSet = INS
             cursor.position() - startingPosition
         ];
     } catch (error) {
-        if (error instanceof InvalidOpcodeError || error instanceof AvmExecutionError) {
-            throw error;
+        if (error instanceof InvalidTagValueError || error instanceof InvalidOpcodeError) {
+            throw duringInstrFetch(error, pc);
+        } else if (error instanceof AvmExecutionError) {
+            throw new AvmParsingError(`Instruction parsing error at pc ${pc}: ${error.message}`);
         } else {
-            throw new AvmParsingError(`${error}`);
+            const msg = error instanceof Error ? `: ${error.message}` : '';
+            throw new AvmParsingError(`Instruction fetching error at pc ${pc}${msg}`);
         }
     }
 }