@aztec/simulator 0.0.0-test.0

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

@@ -0,0 +1,69 @@
+import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
+import { InvalidToRadixInputsError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+export class ToRadixBE extends Instruction {
+    indirect;
+    srcOffset;
+    radixOffset;
+    numLimbsOffset;
+    outputBitsOffset;
+    dstOffset;
+    static type = 'TORADIXBE';
+    static opcode = Opcode.TORADIXBE;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset){
+        super(), this.indirect = indirect, this.srcOffset = srcOffset, this.radixOffset = radixOffset, this.numLimbsOffset = numLimbsOffset, this.outputBitsOffset = outputBitsOffset, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.srcOffset,
+            this.radixOffset,
+            this.numLimbsOffset,
+            this.outputBitsOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
+        // The radix gadget only takes in a Field
+        memory.checkTag(TypeTag.FIELD, srcOffset);
+        memory.checkTag(TypeTag.UINT32, radixOffset);
+        memory.checkTag(TypeTag.UINT32, numLimbsOffset);
+        memory.checkTag(TypeTag.UINT1, outputBitsOffset);
+        const numLimbs = memory.get(numLimbsOffset).toNumber();
+        context.machineState.consumeGas(this.gasCost(numLimbs));
+        const outputBits = memory.get(outputBitsOffset).toNumber();
+        let value = memory.get(srcOffset).toBigInt();
+        const radix = memory.get(radixOffset).toBigInt();
+        if (radix < 2 || radix > 256) {
+            throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
+        }
+        if (numLimbs < 1 && value != BigInt(0n)) {
+            throw new InvalidToRadixInputsError(`ToRadixBE instruction's input value is not zero (was ${value}) but numLimbs zero.`);
+        }
+        if (outputBits != 0 && radix != BigInt(2n)) {
+            throw new InvalidToRadixInputsError(`Radix ${radix} is not equal to 2 and bit mode is activated.`);
+        }
+        const radixBN = BigInt(radix);
+        const limbArray = new Array(numLimbs);
+        for(let i = numLimbs - 1; i >= 0; i--){
+            const limb = value % radixBN;
+            limbArray[i] = limb;
+            value /= radixBN;
+        }
+        const outputType = outputBits != 0 ? Uint1 : Uint8;
+        const res = limbArray.map((byte)=>new outputType(byte));
+        memory.setSlice(dstOffset, res);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+export declare class EcAdd extends Instruction {
+    private indirect;
+    private p1XOffset;
+    private p1YOffset;
+    private p1IsInfiniteOffset;
+    private p2XOffset;
+    private p2YOffset;
+    private p2IsInfiniteOffset;
+    private dstOffset;
+    static type: string;
+    static readonly opcode = Opcode.ECADD;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, p1XOffset: number, p1YOffset: number, p1IsInfiniteOffset: number, p2XOffset: number, p2YOffset: number, p2IsInfiniteOffset: number, dstOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+//# sourceMappingURL=ec_add.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ec_add.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/ec_add.ts"],"names":[],"mappings":"AAGA,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,KAAM,SAAQ,WAAW;IAkBlC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,SAAS;IAxBnB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAW;IAC9B,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAGtC,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAUvC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM;IAKd,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAqDzD"}

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

@@ -0,0 +1,84 @@
+import { Grumpkin } from '@aztec/foundation/crypto';
+import { Point } from '@aztec/foundation/fields';
+import { Field, 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';
+export class EcAdd extends Instruction {
+    indirect;
+    p1XOffset;
+    p1YOffset;
+    p1IsInfiniteOffset;
+    p2XOffset;
+    p2YOffset;
+    p2IsInfiniteOffset;
+    dstOffset;
+    static type = 'ECADD';
+    static opcode = Opcode.ECADD;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset){
+        super(), this.indirect = indirect, this.p1XOffset = p1XOffset, this.p1YOffset = p1YOffset, this.p1IsInfiniteOffset = p1IsInfiniteOffset, this.p2XOffset = p2XOffset, this.p2YOffset = p2YOffset, this.p2IsInfiniteOffset = p2IsInfiniteOffset, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.p1XOffset,
+            this.p1YOffset,
+            this.p1IsInfiniteOffset,
+            this.p2XOffset,
+            this.p2YOffset,
+            this.p2IsInfiniteOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] = addressing.resolve(operands, memory);
+        memory.checkTags(TypeTag.FIELD, p1XOffset, p1YOffset, p2XOffset, p2YOffset);
+        memory.checkTags(TypeTag.UINT1, p1IsInfiniteOffset, p2IsInfiniteOffset);
+        const p1X = memory.get(p1XOffset);
+        const p1Y = memory.get(p1YOffset);
+        const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
+        const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
+        if (!p1.isOnGrumpkin()) {
+            throw new Error(`Point1 is not on the curve`);
+        }
+        const p2X = memory.get(p2XOffset);
+        const p2Y = memory.get(p2YOffset);
+        // unused. Point doesn't store this information
+        const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
+        const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
+        if (!p2.isOnGrumpkin()) {
+            throw new Error(`Point1 is not on the curve`);
+        }
+        const grumpkin = new Grumpkin();
+        let dest;
+        if (p1IsInfinite) {
+            dest = p2;
+        } else if (p2IsInfinite) {
+            dest = p1;
+        } else {
+            dest = await grumpkin.add(p1, p2);
+        }
+        // Important to use setSlice() and not set() in the two following statements as
+        // this checks that the offsets lie within memory range.
+        memory.setSlice(dstOffset, [
+            new Field(dest.x),
+            new Field(dest.y)
+        ]);
+        // Check representation of infinity for grumpkin
+        memory.setSlice(dstOffset + 2, [
+            new Uint1(dest.equals(Point.ZERO) ? 1 : 0)
+        ]);
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+export declare enum EnvironmentVariable {
+    ADDRESS = 0,
+    SENDER = 1,
+    TRANSACTIONFEE = 2,
+    CHAINID = 3,
+    VERSION = 4,
+    BLOCKNUMBER = 5,
+    TIMESTAMP = 6,
+    FEEPERL2GAS = 7,
+    FEEPERDAGAS = 8,
+    ISSTATICCALL = 9,
+    L2GASLEFT = 10,
+    DAGASLEFT = 11
+}
+export declare class GetEnvVar extends Instruction {
+    private indirect;
+    private dstOffset;
+    private varEnum;
+    static readonly type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat16: OperandType[];
+    constructor(indirect: number, dstOffset: number, varEnum: number);
+    execute(context: AvmContext): Promise<void>;
+}
+//# sourceMappingURL=environment_getters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environment_getters.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/environment_getters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,oBAAY,mBAAmB;IAC7B,OAAO,IAAA;IACP,MAAM,IAAA;IACN,cAAc,IAAA;IACd,OAAO,IAAA;IACP,OAAO,IAAA;IACP,WAAW,IAAA;IACX,SAAS,IAAA;IACT,WAAW,IAAA;IACX,WAAW,IAAA;IACX,YAAY,IAAA;IACZ,SAAS,KAAA;IACT,SAAS,KAAA;CACV;AAiCD,qBAAa,SAAU,SAAQ,WAAW;IAU5B,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,SAAS;IAAU,OAAO,CAAC,OAAO;IAThF,gBAAuB,IAAI,EAAE,MAAM,CAAe;IAClD,gBAAuB,MAAM,EAAE,MAAM,CAAuB;IAC5D,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,WAAW,EAAE,CAKzC;gBAEkB,QAAQ,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM,EAAU,OAAO,EAAE,MAAM;IAI3E,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAczD"}

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

@@ -0,0 +1,79 @@
+import { Field, Uint64 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+export var EnvironmentVariable = /*#__PURE__*/ function(EnvironmentVariable) {
+    EnvironmentVariable[EnvironmentVariable["ADDRESS"] = 0] = "ADDRESS";
+    EnvironmentVariable[EnvironmentVariable["SENDER"] = 1] = "SENDER";
+    EnvironmentVariable[EnvironmentVariable["TRANSACTIONFEE"] = 2] = "TRANSACTIONFEE";
+    EnvironmentVariable[EnvironmentVariable["CHAINID"] = 3] = "CHAINID";
+    EnvironmentVariable[EnvironmentVariable["VERSION"] = 4] = "VERSION";
+    EnvironmentVariable[EnvironmentVariable["BLOCKNUMBER"] = 5] = "BLOCKNUMBER";
+    EnvironmentVariable[EnvironmentVariable["TIMESTAMP"] = 6] = "TIMESTAMP";
+    EnvironmentVariable[EnvironmentVariable["FEEPERL2GAS"] = 7] = "FEEPERL2GAS";
+    EnvironmentVariable[EnvironmentVariable["FEEPERDAGAS"] = 8] = "FEEPERDAGAS";
+    EnvironmentVariable[EnvironmentVariable["ISSTATICCALL"] = 9] = "ISSTATICCALL";
+    EnvironmentVariable[EnvironmentVariable["L2GASLEFT"] = 10] = "L2GASLEFT";
+    EnvironmentVariable[EnvironmentVariable["DAGASLEFT"] = 11] = "DAGASLEFT";
+    return EnvironmentVariable;
+}({});
+function getValue(e, ctx) {
+    switch(e){
+        case 0:
+            return new Field(ctx.environment.address.toField());
+        case 1:
+            return new Field(ctx.environment.sender.toField());
+        case 2:
+            return new Field(ctx.environment.transactionFee);
+        case 3:
+            return new Field(ctx.environment.globals.chainId);
+        case 4:
+            return new Field(ctx.environment.globals.version);
+        case 5:
+            return new Field(ctx.environment.globals.blockNumber);
+        case 6:
+            return new Uint64(ctx.environment.globals.timestamp.toBigInt());
+        case 7:
+            return new Field(ctx.environment.globals.gasFees.feePerL2Gas);
+        case 8:
+            return new Field(ctx.environment.globals.gasFees.feePerDaGas);
+        case 9:
+            return new Field(ctx.environment.isStaticCall ? 1 : 0);
+        case 10:
+            return new Field(ctx.machineState.l2GasLeft);
+        case 11:
+            return new Field(ctx.machineState.daGasLeft);
+        default:
+            throw new Error(`Unknown environment variable ${e}`);
+    }
+}
+export class GetEnvVar extends Instruction {
+    indirect;
+    dstOffset;
+    varEnum;
+    static type = 'GETENVVAR';
+    static opcode = Opcode.GETENVVAR_16;
+    static wireFormat16 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT8
+    ];
+    constructor(indirect, dstOffset, varEnum){
+        super(), this.indirect = indirect, this.dstOffset = dstOffset, this.varEnum = varEnum;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        if (!(this.varEnum in EnvironmentVariable)) {
+            throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${this.varEnum}`);
+        }
+        const operands = [
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [dstOffset] = addressing.resolve(operands, memory);
+        memory.set(dstOffset, getValue(this.varEnum, context));
+    }
+}

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

@@ -0,0 +1,58 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+declare abstract class ExternalCall extends Instruction {
+    private indirect;
+    private gasOffset;
+    private addrOffset;
+    private argsOffset;
+    private argsSizeOffset;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, gasOffset: number, addrOffset: number, argsOffset: number, argsSizeOffset: number);
+    execute(context: AvmContext): Promise<void>;
+    abstract get type(): 'CALL' | 'STATICCALL';
+}
+export declare class Call extends ExternalCall {
+    static type: "CALL";
+    static readonly opcode: Opcode;
+    get type(): "CALL";
+}
+export declare class StaticCall extends ExternalCall {
+    static type: "STATICCALL";
+    static readonly opcode: Opcode;
+    get type(): "STATICCALL";
+}
+export declare class SuccessCopy extends Instruction {
+    private indirect;
+    private dstOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, dstOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class Return extends Instruction {
+    private indirect;
+    private returnOffset;
+    private returnSizeOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, returnOffset: number, returnSizeOffset: number);
+    execute(context: AvmContext): Promise<void>;
+    handlesPC(): boolean;
+}
+export declare class Revert extends Instruction {
+    private indirect;
+    private returnOffset;
+    private retSizeOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat8: OperandType[];
+    static readonly wireFormat16: OperandType[];
+    constructor(indirect: number, returnOffset: number, retSizeOffset: number);
+    execute(context: AvmContext): Promise<void>;
+    handlesPC(): boolean;
+}
+export {};
+//# sourceMappingURL=external_calls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"external_calls.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/external_calls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,uBAAe,YAAa,SAAQ,WAAW;IAY3C,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,cAAc;IAdxB,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAOvC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM;IAKnB,OAAO,CAAC,OAAO,EAAE,UAAU;IAmExC,aAA6B,IAAI,IAAI,MAAM,GAAG,YAAY,CAAC;CAC5D;AAED,qBAAa,IAAK,SAAQ,YAAY;IACpC,MAAM,CAAC,IAAI,SAAmB;IAC9B,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAe;IAE7C,IAAW,IAAI,WAEd;CACF;AAED,qBAAa,UAAW,SAAQ,YAAY;IAC1C,MAAM,CAAC,IAAI,eAAyB;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAqB;IAEnD,IAAW,IAAI,iBAEd;CACF;AAED,qBAAa,WAAY,SAAQ,WAAW;IAU9B,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,SAAS;IATvD,MAAM,CAAC,IAAI,EAAE,MAAM,CAAiB;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAsB;IAEpD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAIvC;gBAEkB,QAAQ,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM;IAIlD,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAazD;AAED,qBAAa,MAAO,SAAQ,WAAW;IAWzB,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,YAAY;IAAU,OAAO,CAAC,gBAAgB;IAV5F,MAAM,CAAC,IAAI,EAAE,MAAM,CAAY;IAC/B,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAiB;IAE/C,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAKvC;gBAEkB,QAAQ,EAAE,MAAM,EAAU,YAAY,EAAE,MAAM,EAAU,gBAAgB,EAAE,MAAM;IAIvF,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxC,SAAS,IAAI,OAAO;CAGrC;AAED,qBAAa,MAAO,SAAQ,WAAW;IAiBzB,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,YAAY;IAAU,OAAO,CAAC,aAAa;IAhBzF,MAAM,CAAC,IAAI,EAAE,MAAM,CAAY;IAC/B,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAmB;IAEjD,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,CAKxC;IACF,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,WAAW,EAAE,CAKzC;gBAEkB,QAAQ,EAAE,MAAM,EAAU,YAAY,EAAE,MAAM,EAAU,aAAa,EAAE,MAAM;IAIpF,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBxC,SAAS,IAAI,OAAO;CAGrC"}

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

@@ -0,0 +1,204 @@
+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;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        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;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.gasOffset,
+            this.addrOffset,
+            this.argsOffset,
+            this.argsSizeOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [gasOffset, addrOffset, argsOffset, argsSizeOffset] = 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;
+        // Track the success status directly
+        context.machineState.nestedCallSuccess = success;
+        // 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
+            };
+        }
+        // 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 SuccessCopy extends Instruction {
+    indirect;
+    dstOffset;
+    static type = 'SUCCESSCOPY';
+    static opcode = Opcode.SUCCESSCOPY;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16
+    ];
+    constructor(indirect, dstOffset){
+        super(), this.indirect = indirect, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        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;
+        // Write the success flag to the provided memory location
+        memory.set(dstOffset, new Uint1(success ? 1 : 0));
+    }
+}
+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/public/avm/opcodes/hashing.d.ts

@@ -0,0 +1,36 @@
+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 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);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class KeccakF1600 extends Instruction {
+    private indirect;
+    private dstOffset;
+    private inputOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, dstOffset: number, inputOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class Sha256Compression extends Instruction {
+    private indirect;
+    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);
+    execute(context: AvmContext): Promise<void>;
+}
+//# sourceMappingURL=hashing.d.ts.map

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"}