@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

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

@@ -1 +0,0 @@
-{"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;AAGpD,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;CAuDzD"}

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

@@ -1,84 +0,0 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import { Point } from '@aztec/foundation/fields';
-import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { EcAddPointNotOnCurveError } from '../errors.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;
-        const addressing = Addressing.fromWire(this.indirect);
-        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
-        const operands = [
-            this.p1XOffset,
-            this.p1YOffset,
-            this.p1IsInfiniteOffset,
-            this.p2XOffset,
-            this.p2YOffset,
-            this.p2IsInfiniteOffset,
-            this.dstOffset
-        ];
-        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 EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
-        }
-        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 EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
-        }
-        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

@@ -1,28 +0,0 @@
-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,
-    BASEFEEPERL2GAS = 7,
-    BASEFEEPERDAGAS = 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

@@ -1 +0,0 @@
-{"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,eAAe,IAAA;IACf,eAAe,IAAA;IACf,YAAY,IAAA;IACZ,SAAS,KAAA;IACT,SAAS,KAAA;CACV;AAiCD,qBAAa,SAAU,SAAQ,WAAW;IAWtC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,OAAO;IAZjB,gBAAuB,IAAI,EAAE,MAAM,CAAe;IAClD,gBAAuB,MAAM,EAAE,MAAM,CAAuB;IAC5D,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,WAAW,EAAE,CAKzC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM;IAKZ,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAezD"}

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

@@ -1,77 +0,0 @@
-import { Field, Uint1, Uint32, Uint64, Uint128 } 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["BASEFEEPERL2GAS"] = 7] = "BASEFEEPERL2GAS";
-    EnvironmentVariable[EnvironmentVariable["BASEFEEPERDAGAS"] = 8] = "BASEFEEPERDAGAS";
-    EnvironmentVariable[EnvironmentVariable["ISSTATICCALL"] = 9] = "ISSTATICCALL";
-    EnvironmentVariable[EnvironmentVariable["L2GASLEFT"] = 10] = "L2GASLEFT";
-    EnvironmentVariable[EnvironmentVariable["DAGASLEFT"] = 11] = "DAGASLEFT";
-    return EnvironmentVariable;
-}({});
-function getValue(varEnum, ctx) {
-    switch(varEnum){
-        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 Uint32(ctx.environment.globals.blockNumber);
-        case 6:
-            return new Uint64(ctx.environment.globals.timestamp);
-        case 7:
-            return new Uint128(ctx.environment.globals.gasFees.feePerL2Gas);
-        case 8:
-            return new Uint128(ctx.environment.globals.gasFees.feePerDaGas);
-        case 9:
-            return new Uint1(ctx.environment.isStaticCall ? 1 : 0);
-        case 10:
-            return new Uint32(ctx.machineState.l2GasLeft);
-        case 11:
-            return new Uint32(ctx.machineState.daGasLeft);
-        default:
-            throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${varEnum}`);
-    }
-}
-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;
-        const addressing = Addressing.fromWire(this.indirect);
-        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
-        const operands = [
-            this.dstOffset
-        ];
-        const [dstOffset] = addressing.resolve(operands, memory);
-        const value = getValue(this.varEnum, context);
-        memory.set(dstOffset, value);
-    }
-}

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

@@ -1,59 +0,0 @@
-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 l2GasOffset;
-    private daGasOffset;
-    private addrOffset;
-    private argsSizeOffset;
-    private argsOffset;
-    static readonly wireFormat: OperandType[];
-    constructor(indirect: number, l2GasOffset: number, daGasOffset: number, addrOffset: number, argsSizeOffset: number, argsOffset: 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 returnSizeOffset;
-    private returnOffset;
-    static type: string;
-    static readonly opcode: Opcode;
-    static readonly wireFormat: OperandType[];
-    constructor(indirect: number, returnSizeOffset: number, returnOffset: number);
-    execute(context: AvmContext): Promise<void>;
-    handlesPC(): boolean;
-}
-export declare class Revert extends Instruction {
-    private indirect;
-    private retSizeOffset;
-    private returnOffset;
-    static type: string;
-    static readonly opcode: Opcode;
-    static readonly wireFormat8: OperandType[];
-    static readonly wireFormat16: OperandType[];
-    constructor(indirect: number, retSizeOffset: number, returnOffset: 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

@@ -1 +0,0 @@
-{"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;IAa3C,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,UAAU;IAhBpB,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAQvC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM;IAKf,OAAO,CAAC,OAAO,EAAE,UAAU;IA4ExC,aAA6B,IAAI,IAAI,MAAM,GAAG,YAAY,CAAC;CAC5D;AAED,qBAAa,IAAK,SAAQ,YAAY;IACpC,MAAM,CAAC,IAAI,EAAG,MAAM,CAAU;IAC9B,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAe;IAE7C,IAAW,IAAI,WAEd;CACF;AAED,qBAAa,UAAW,SAAQ,YAAY;IAC1C,MAAM,CAAC,IAAI,EAAG,YAAY,CAAU;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAqB;IAEnD,IAAW,IAAI,iBAEd;CACF;AAED,qBAAa,WAAY,SAAQ,WAAW;IAWxC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IAXnB,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;gBAGQ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;IAKd,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBzD;AAED,qBAAa,MAAO,SAAQ,WAAW;IAYnC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,YAAY;IAbtB,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;gBAGQ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,MAAM;IAKjB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxC,SAAS,IAAI,OAAO;CAGrC;AAED,qBAAa,MAAO,SAAQ,WAAW;IAkBnC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,YAAY;IAnBtB,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;gBAGQ,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM;IAKjB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBxC,SAAS,IAAI,OAAO;CAGrC"}

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

@@ -1,209 +0,0 @@
-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;
-    l2GasOffset;
-    daGasOffset;
-    addrOffset;
-    argsSizeOffset;
-    argsOffset;
-    // Informs (de)serialization. See Instruction.deserialize.
-    static wireFormat = [
-        OperandType.UINT8,
-        OperandType.UINT16,
-        OperandType.UINT16,
-        OperandType.UINT16,
-        OperandType.UINT16,
-        OperandType.UINT16,
-        OperandType.UINT16
-    ];
-    constructor(indirect, l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset){
-        super(), this.indirect = indirect, 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.indirect);
-        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
-        const operands = [
-            this.l2GasOffset,
-            this.daGasOffset,
-            this.addrOffset,
-            this.argsSizeOffset,
-            this.argsOffset
-        ];
-        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());
-        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;
-        // 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(l2GasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)));
-        const allocatedDaGas = Number(BigIntMin(memory.get(daGasOffset).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;
-        // 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
-        // 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 addressing = Addressing.fromWire(this.indirect);
-        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
-        const operands = [
-            this.dstOffset
-        ];
-        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;
-    returnSizeOffset;
-    returnOffset;
-    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, returnSizeOffset, returnOffset){
-        super(), this.indirect = indirect, this.returnSizeOffset = returnSizeOffset, this.returnOffset = returnOffset;
-    }
-    async execute(context) {
-        const memory = context.machineState.memory;
-        const addressing = Addressing.fromWire(this.indirect);
-        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
-        const operands = [
-            this.returnSizeOffset,
-            this.returnOffset
-        ];
-        const [returnSizeOffset, returnOffset] = addressing.resolve(operands, memory);
-        memory.checkTag(TypeTag.UINT32, returnSizeOffset);
-        const returnSize = memory.get(returnSizeOffset).toNumber();
-        const output = memory.getSlice(returnOffset, returnSize).map((word)=>word.toFr());
-        context.machineState.return(output);
-    }
-    handlesPC() {
-        return true;
-    }
-}
-export class Revert extends Instruction {
-    indirect;
-    retSizeOffset;
-    returnOffset;
-    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, retSizeOffset, returnOffset){
-        super(), this.indirect = indirect, this.retSizeOffset = retSizeOffset, this.returnOffset = returnOffset;
-    }
-    async execute(context) {
-        const memory = context.machineState.memory;
-        const addressing = Addressing.fromWire(this.indirect);
-        context.machineState.consumeGas(this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()));
-        const operands = [
-            this.retSizeOffset,
-            this.returnOffset
-        ];
-        const [retSizeOffset, returnOffset] = addressing.resolve(operands, memory);
-        memory.checkTag(TypeTag.UINT32, retSizeOffset);
-        const retSize = memory.get(retSizeOffset).toNumber();
-        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

@@ -1,36 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;IActC,OAAO,CAAC,QAAQ;IAChB,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;gBAGQ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,iBAAiB,EAAE,MAAM;IAKtB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAqBzD;AAED,qBAAa,WAAY,SAAQ,WAAW;IAaxC,OAAO,CAAC,QAAQ;IAChB,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;gBAGQ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM;IAMhB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBzD;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;CA2BzD"}

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

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

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

@@ -1,16 +0,0 @@
-export * from './arithmetic.js';
-export * from './bitwise.js';
-export * from './control_flow.js';
-export * from './contract.js';
-export * from './conversion.js';
-export * from './instruction.js';
-export * from './comparators.js';
-export * from './memory.js';
-export * from './misc.js';
-export * from './storage.js';
-export * from './external_calls.js';
-export * from './environment_getters.js';
-export * from './accrued_substate.js';
-export * from './hashing.js';
-export * from './ec_add.js';
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,15 +0,0 @@
-export * from './arithmetic.js';
-export * from './bitwise.js';
-export * from './control_flow.js';
-export * from './contract.js';
-export * from './conversion.js';
-export * from './instruction.js';
-export * from './comparators.js';
-export * from './memory.js';
-export * from './misc.js';
-export * from './storage.js';
-export * from './external_calls.js';
-export * from './environment_getters.js';
-export * from './accrued_substate.js';
-export * from './hashing.js';
-export * from './ec_add.js';