@aztec/simulator 0.0.0-test.0

package/dest/public/avm/avm_gas.js

@@ -0,0 +1,203 @@
+import * as c from '@aztec/constants';
+import { TypeTag } from './avm_memory_types.js';
+import { InstructionExecutionError } from './errors.js';
+import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
+import { Opcode } from './serialization/instruction_serialization.js';
+/** Maps a Gas struct to gasLeft properties. */ export function gasToGasLeft(gas) {
+    return {
+        l2GasLeft: gas.l2Gas,
+        daGasLeft: gas.daGas
+    };
+}
+/** Maps gasLeft properties to a gas struct. */ export function gasLeftToGas(gasLeft) {
+    return {
+        l2Gas: gasLeft.l2GasLeft,
+        daGas: gasLeft.daGasLeft
+    };
+}
+/** Creates a new instance with all values set to zero except the ones set. */ export function makeGas(gasCost) {
+    return {
+        ...EmptyGas,
+        ...gasCost
+    };
+}
+/** Sums together multiple instances of Gas. */ export function sumGas(...gases) {
+    return gases.reduce((acc, gas)=>({
+            l2Gas: acc.l2Gas + (gas.l2Gas ?? 0),
+            daGas: acc.daGas + (gas.daGas ?? 0)
+        }), EmptyGas);
+}
+/** Multiplies a gas instance by a scalar. */ export function mulGas(gas, scalar) {
+    return {
+        l2Gas: (gas.l2Gas ?? 0) * scalar,
+        daGas: (gas.daGas ?? 0) * scalar
+    };
+}
+/** Zero gas across all gas dimensions. */ export const EmptyGas = {
+    l2Gas: 0,
+    daGas: 0
+};
+function makeCost(l2Gas, daGas) {
+    return {
+        l2Gas,
+        daGas
+    };
+}
+/** Dimensions of gas usage: L1, L2, and DA. */ export const GAS_DIMENSIONS = [
+    'l2Gas',
+    'daGas'
+];
+/** Base gas costs for each instruction. Additional gas cost may be added on top due to memory or storage accesses, etc. */ const BASE_GAS_COSTS = {
+    [Opcode.ADD_8]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
+    [Opcode.ADD_16]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
+    [Opcode.SUB_8]: makeCost(c.AVM_SUB_BASE_L2_GAS, 0),
+    [Opcode.SUB_16]: makeCost(c.AVM_SUB_BASE_L2_GAS, 0),
+    [Opcode.MUL_8]: makeCost(c.AVM_MUL_BASE_L2_GAS, 0),
+    [Opcode.MUL_16]: makeCost(c.AVM_MUL_BASE_L2_GAS, 0),
+    [Opcode.DIV_8]: makeCost(c.AVM_DIV_BASE_L2_GAS, 0),
+    [Opcode.DIV_16]: makeCost(c.AVM_DIV_BASE_L2_GAS, 0),
+    [Opcode.FDIV_8]: makeCost(c.AVM_FDIV_BASE_L2_GAS, 0),
+    [Opcode.FDIV_16]: makeCost(c.AVM_FDIV_BASE_L2_GAS, 0),
+    [Opcode.EQ_8]: makeCost(c.AVM_EQ_BASE_L2_GAS, 0),
+    [Opcode.EQ_16]: makeCost(c.AVM_EQ_BASE_L2_GAS, 0),
+    [Opcode.LT_8]: makeCost(c.AVM_LT_BASE_L2_GAS, 0),
+    [Opcode.LT_16]: makeCost(c.AVM_LT_BASE_L2_GAS, 0),
+    [Opcode.LTE_8]: makeCost(c.AVM_LTE_BASE_L2_GAS, 0),
+    [Opcode.LTE_16]: makeCost(c.AVM_LTE_BASE_L2_GAS, 0),
+    [Opcode.AND_8]: makeCost(c.AVM_AND_BASE_L2_GAS, 0),
+    [Opcode.AND_16]: makeCost(c.AVM_AND_BASE_L2_GAS, 0),
+    [Opcode.OR_8]: makeCost(c.AVM_OR_BASE_L2_GAS, 0),
+    [Opcode.OR_16]: makeCost(c.AVM_OR_BASE_L2_GAS, 0),
+    [Opcode.XOR_8]: makeCost(c.AVM_XOR_BASE_L2_GAS, 0),
+    [Opcode.XOR_16]: makeCost(c.AVM_XOR_BASE_L2_GAS, 0),
+    [Opcode.NOT_8]: makeCost(c.AVM_NOT_BASE_L2_GAS, 0),
+    [Opcode.NOT_16]: makeCost(c.AVM_NOT_BASE_L2_GAS, 0),
+    [Opcode.SHL_8]: makeCost(c.AVM_SHL_BASE_L2_GAS, 0),
+    [Opcode.SHL_16]: makeCost(c.AVM_SHL_BASE_L2_GAS, 0),
+    [Opcode.SHR_8]: makeCost(c.AVM_SHR_BASE_L2_GAS, 0),
+    [Opcode.SHR_16]: makeCost(c.AVM_SHR_BASE_L2_GAS, 0),
+    [Opcode.CAST_8]: makeCost(c.AVM_CAST_BASE_L2_GAS, 0),
+    [Opcode.CAST_16]: makeCost(c.AVM_CAST_BASE_L2_GAS, 0),
+    [Opcode.GETENVVAR_16]: makeCost(c.AVM_GETENVVAR_BASE_L2_GAS, 0),
+    [Opcode.CALLDATACOPY]: makeCost(c.AVM_CALLDATACOPY_BASE_L2_GAS, 0),
+    [Opcode.SUCCESSCOPY]: makeCost(c.AVM_SUCCESSCOPY_BASE_L2_GAS, 0),
+    [Opcode.RETURNDATASIZE]: makeCost(c.AVM_RETURNDATASIZE_BASE_L2_GAS, 0),
+    [Opcode.RETURNDATACOPY]: makeCost(c.AVM_RETURNDATACOPY_BASE_L2_GAS, 0),
+    [Opcode.JUMP_32]: makeCost(c.AVM_JUMP_BASE_L2_GAS, 0),
+    [Opcode.JUMPI_32]: makeCost(c.AVM_JUMPI_BASE_L2_GAS, 0),
+    [Opcode.INTERNALCALL]: makeCost(c.AVM_INTERNALCALL_BASE_L2_GAS, 0),
+    [Opcode.INTERNALRETURN]: makeCost(c.AVM_INTERNALRETURN_BASE_L2_GAS, 0),
+    [Opcode.SET_8]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+    [Opcode.SET_16]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+    [Opcode.SET_32]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+    [Opcode.SET_64]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+    [Opcode.SET_128]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+    [Opcode.SET_FF]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+    [Opcode.MOV_8]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
+    [Opcode.MOV_16]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
+    [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_BASE_L2_GAS, 0),
+    [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, c.AVM_SSTORE_BASE_DA_GAS),
+    [Opcode.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_BASE_L2_GAS, 0),
+    [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_BASE_L2_GAS, c.AVM_EMITNOTEHASH_BASE_DA_GAS),
+    [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_BASE_L2_GAS, 0),
+    [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_BASE_L2_GAS, c.AVM_EMITNULLIFIER_BASE_DA_GAS),
+    [Opcode.L1TOL2MSGEXISTS]: makeCost(c.AVM_L1TOL2MSGEXISTS_BASE_L2_GAS, 0),
+    [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_BASE_L2_GAS, 0),
+    [Opcode.SENDL2TOL1MSG]: makeCost(c.AVM_SENDL2TOL1MSG_BASE_L2_GAS, c.AVM_SENDL2TOL1MSG_BASE_DA_GAS),
+    [Opcode.GETCONTRACTINSTANCE]: makeCost(c.AVM_GETCONTRACTINSTANCE_BASE_L2_GAS, 0),
+    [Opcode.CALL]: makeCost(c.AVM_CALL_BASE_L2_GAS, 0),
+    [Opcode.STATICCALL]: makeCost(c.AVM_STATICCALL_BASE_L2_GAS, 0),
+    [Opcode.RETURN]: makeCost(c.AVM_RETURN_BASE_L2_GAS, 0),
+    [Opcode.REVERT_8]: makeCost(c.AVM_REVERT_BASE_L2_GAS, 0),
+    [Opcode.REVERT_16]: makeCost(c.AVM_REVERT_BASE_L2_GAS, 0),
+    [Opcode.DEBUGLOG]: makeCost(c.AVM_DEBUGLOG_BASE_L2_GAS, 0),
+    [Opcode.POSEIDON2]: makeCost(c.AVM_POSEIDON2_BASE_L2_GAS, 0),
+    [Opcode.SHA256COMPRESSION]: makeCost(c.AVM_SHA256COMPRESSION_BASE_L2_GAS, 0),
+    [Opcode.KECCAKF1600]: makeCost(c.AVM_KECCAKF1600_BASE_L2_GAS, 0),
+    [Opcode.ECADD]: makeCost(c.AVM_ECADD_BASE_L2_GAS, 0),
+    [Opcode.TORADIXBE]: makeCost(c.AVM_TORADIXBE_BASE_L2_GAS, 0)
+};
+const DYNAMIC_GAS_COSTS = new Map([
+    [
+        Opcode.CALLDATACOPY,
+        makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.RETURNDATACOPY,
+        makeCost(c.AVM_RETURNDATACOPY_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.EMITUNENCRYPTEDLOG,
+        makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_DYN_DA_GAS)
+    ],
+    [
+        Opcode.CALL,
+        makeCost(c.AVM_CALL_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.STATICCALL,
+        makeCost(c.AVM_STATICCALL_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.RETURN,
+        makeCost(c.AVM_RETURN_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.REVERT_8,
+        makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.REVERT_16,
+        makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.DEBUGLOG,
+        makeCost(c.AVM_DEBUGLOG_DYN_L2_GAS, 0)
+    ],
+    [
+        Opcode.TORADIXBE,
+        makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)
+    ]
+]);
+/** Returns the fixed base gas cost for a given opcode. */ export function getBaseGasCost(opcode) {
+    return BASE_GAS_COSTS[opcode];
+}
+export function getDynamicGasCost(opcode) {
+    return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode) : makeCost(0, 0);
+}
+/** Returns the gas cost associated with the memory operations performed. */ export function getMemoryGasCost(args) {
+    const { reads, writes, indirect } = args;
+    const indirectCount = Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
+    const l2MemoryGasCost = (reads ?? 0) * GAS_COST_CONSTANTS.MEMORY_READ + (writes ?? 0) * GAS_COST_CONSTANTS.MEMORY_WRITE + indirectCount * GAS_COST_CONSTANTS.MEMORY_INDIRECT_READ_PENALTY;
+    return makeGas({
+        l2Gas: l2MemoryGasCost
+    });
+}
+/** Constants used in base cost calculations. */ export const GAS_COST_CONSTANTS = {
+    MEMORY_READ: 10,
+    MEMORY_INDIRECT_READ_PENALTY: 10,
+    MEMORY_WRITE: 100
+};
+/** Returns gas cost for an operation on a given type tag based on the base cost per byte. */ export function getGasCostForTypeTag(tag, baseCost) {
+    return mulGas(baseCost, getGasCostMultiplierFromTypeTag(tag));
+}
+/** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */ function getGasCostMultiplierFromTypeTag(tag) {
+    switch(tag){
+        case TypeTag.UINT1:
+            return 1;
+        case TypeTag.UINT8:
+            return 1;
+        case TypeTag.UINT16:
+            return 2;
+        case TypeTag.UINT32:
+            return 4;
+        case TypeTag.UINT64:
+            return 8;
+        case TypeTag.UINT128:
+            return 16;
+        case TypeTag.FIELD:
+            return 32;
+        case TypeTag.INVALID:
+            throw new InstructionExecutionError(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
+    }
+}

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

@@ -0,0 +1,95 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { Gas } from './avm_gas.js';
+import { TaggedMemory } from './avm_memory_types.js';
+import { type AvmRevertReason } from './errors.js';
+/**
+ * A few fields of machine state are initialized from AVM session inputs or call instruction arguments
+ */
+export type InitialAvmMachineState = {
+    l2GasLeft: number;
+    daGasLeft: number;
+};
+/**
+ * Used to track the call stack and revert data of nested calls.
+ * This is used to provide a more detailed revert reason when a contract call reverts.
+ * It is only a heuristic and may not always provide the correct revert reason.
+ */
+type TrackedRevertInfo = {
+    revertDataRepresentative: Fr[];
+    recursiveRevertReason: AvmRevertReason;
+};
+type CallStackEntry = {
+    callPc: number;
+    returnPc: number;
+};
+/**
+ * Avm state modified on an instruction-per-instruction basis.
+ */
+export declare class AvmMachineState {
+    /** gas remaining of the gas allocated for a contract call */
+    l2GasLeft: number;
+    daGasLeft: number;
+    /** program counter, byte based */
+    pc: number;
+    /** program counter of the next instruction, byte based */
+    nextPc: number;
+    /** return/revertdata of the last nested call. */
+    nestedReturndata: Fr[];
+    /** Tracks whether the last external call was successful */
+    nestedCallSuccess: boolean;
+    /**
+     * Used to track the call stack and revert data of nested calls.
+     * This is used to provide a more detailed revert reason when a contract call reverts.
+     * It is only a heuristic and may not always provide the correct revert reason.
+     */
+    collectedRevertInfo: TrackedRevertInfo | undefined;
+    /**
+     * On INTERNALCALL, internal call stack is pushed to with the current pc and the return pc.
+     * On INTERNALRETURN, value is popped from the internal call stack and assigned to the return pc.
+     */
+    internalCallStack: CallStackEntry[];
+    /** Memory accessible to user code */
+    readonly memory: TaggedMemory;
+    /**
+     * Signals that execution should end.
+     * AvmContext execution continues executing instructions until the machine state signals "halted"
+     */
+    private halted;
+    /** Signals that execution has reverted normally (this does not cover exceptional halts) */
+    private reverted;
+    /** Output data must NOT be modified once it is set */
+    private output;
+    constructor(gasLeft: Gas);
+    constructor(l2GasLeft: number, daGasLeft: number);
+    get gasLeft(): Gas;
+    static fromState(state: InitialAvmMachineState): AvmMachineState;
+    /**
+     * Consumes the given gas.
+     * Should any of the gas dimensions get depleted, it sets all gas left to zero and triggers
+     * an exceptional halt by throwing an OutOfGasError.
+     */
+    consumeGas(gasCost: Partial<Gas>): void;
+    /** Increases the gas left by the amounts specified. */
+    refundGas(gasRefund: Partial<Gas>): void;
+    /**
+     * Halt as successful
+     * Output data must NOT be modified once it is set
+     * @param output
+     */
+    return(output: Fr[]): void;
+    /**
+     * Halt as reverted
+     * Output data must NOT be modified once it is set
+     * @param output
+     */
+    revert(output: Fr[]): void;
+    getHalted(): boolean;
+    getReverted(): boolean;
+    getOutput(): Fr[];
+    /**
+     * Flag an exceptional halt. Clears gas left and sets the reverted flag. No output data.
+     */
+    private exceptionalHalt;
+}
+export {};
+//# sourceMappingURL=avm_machine_state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"avm_machine_state.d.ts","sourceRoot":"","sources":["../../../src/public/avm/avm_machine_state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,KAAK,eAAe,EAAiB,MAAM,aAAa,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,KAAK,iBAAiB,GAAG;IACvB,wBAAwB,EAAE,EAAE,EAAE,CAAC;IAC/B,qBAAqB,EAAE,eAAe,CAAC;CACxC,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,qBAAa,eAAe;IAC1B,6DAA6D;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IACzB,kCAAkC;IAC3B,EAAE,EAAE,MAAM,CAAK;IACtB,0DAA0D;IACnD,MAAM,EAAE,MAAM,CAAK;IAC1B,iDAAiD;IAC1C,gBAAgB,EAAE,EAAE,EAAE,CAAM;IACnC,2DAA2D;IACpD,iBAAiB,EAAE,OAAO,CAAS;IAC1C;;;;OAIG;IACI,mBAAmB,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAE1D;;;OAGG;IACI,iBAAiB,EAAE,cAAc,EAAE,CAAM;IAEhD,qCAAqC;IACrC,SAAgB,MAAM,EAAE,YAAY,CAAsB;IAE1D;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAkB;IAChC,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,CAAkB;IAClC,sDAAsD;IACtD,OAAO,CAAC,MAAM,CAAY;gBAEd,OAAO,EAAE,GAAG;gBACZ,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAUhD,IAAW,OAAO,IAAI,GAAG,CAExB;WAEa,SAAS,CAAC,KAAK,EAAE,sBAAsB,GAAG,eAAe;IAIvE;;;;OAIG;IACI,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC;IAqBvC,uDAAuD;IAChD,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC;IAKxC;;;;OAIG;IACI,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE;IAK1B;;;;OAIG;IACI,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE;IAMnB,SAAS,IAAI,OAAO;IAIpB,WAAW,IAAI,OAAO;IAItB,SAAS,IAAI,EAAE,EAAE;IAIxB;;OAEG;IACH,OAAO,CAAC,eAAe;CAMxB"}

package/dest/public/avm/avm_machine_state.js

@@ -0,0 +1,107 @@
+import { TaggedMemory } from './avm_memory_types.js';
+import { OutOfGasError } from './errors.js';
+/**
+ * Avm state modified on an instruction-per-instruction basis.
+ */ export class AvmMachineState {
+    /** gas remaining of the gas allocated for a contract call */ l2GasLeft;
+    daGasLeft;
+    /** program counter, byte based */ pc = 0;
+    /** program counter of the next instruction, byte based */ nextPc = 0;
+    /** return/revertdata of the last nested call. */ nestedReturndata = [];
+    /** Tracks whether the last external call was successful */ nestedCallSuccess = false;
+    /**
+   * Used to track the call stack and revert data of nested calls.
+   * This is used to provide a more detailed revert reason when a contract call reverts.
+   * It is only a heuristic and may not always provide the correct revert reason.
+   */ collectedRevertInfo;
+    /**
+   * On INTERNALCALL, internal call stack is pushed to with the current pc and the return pc.
+   * On INTERNALRETURN, value is popped from the internal call stack and assigned to the return pc.
+   */ internalCallStack = [];
+    /** Memory accessible to user code */ memory = new TaggedMemory();
+    /**
+   * Signals that execution should end.
+   * AvmContext execution continues executing instructions until the machine state signals "halted"
+   */ halted = false;
+    /** Signals that execution has reverted normally (this does not cover exceptional halts) */ reverted = false;
+    /** Output data must NOT be modified once it is set */ output = [];
+    constructor(gasLeftOrL2GasLeft, daGasLeft){
+        if (typeof gasLeftOrL2GasLeft === 'object') {
+            ({ l2Gas: this.l2GasLeft, daGas: this.daGasLeft } = gasLeftOrL2GasLeft);
+        } else {
+            this.l2GasLeft = gasLeftOrL2GasLeft;
+            this.daGasLeft = daGasLeft;
+        }
+    }
+    get gasLeft() {
+        return {
+            l2Gas: this.l2GasLeft,
+            daGas: this.daGasLeft
+        };
+    }
+    static fromState(state) {
+        return new AvmMachineState(state.l2GasLeft, state.daGasLeft);
+    }
+    /**
+   * Consumes the given gas.
+   * Should any of the gas dimensions get depleted, it sets all gas left to zero and triggers
+   * an exceptional halt by throwing an OutOfGasError.
+   */ consumeGas(gasCost) {
+        // Assert there is enough gas on every dimension.
+        const outOfL2Gas = this.l2GasLeft - (gasCost.l2Gas ?? 0) < 0;
+        const outOfDaGas = this.daGasLeft - (gasCost.daGas ?? 0) < 0;
+        // If not, trigger an exceptional halt.
+        if (outOfL2Gas || outOfDaGas) {
+            this.exceptionalHalt();
+            const dimensions = [];
+            if (outOfL2Gas) {
+                dimensions.push('l2Gas');
+            }
+            if (outOfDaGas) {
+                dimensions.push('daGas');
+            }
+            throw new OutOfGasError(dimensions);
+        }
+        // Otherwise, charge the corresponding gas
+        this.l2GasLeft -= gasCost.l2Gas ?? 0;
+        this.daGasLeft -= gasCost.daGas ?? 0;
+    }
+    /** Increases the gas left by the amounts specified. */ refundGas(gasRefund) {
+        this.l2GasLeft += gasRefund.l2Gas ?? 0;
+        this.daGasLeft += gasRefund.daGas ?? 0;
+    }
+    /**
+   * Halt as successful
+   * Output data must NOT be modified once it is set
+   * @param output
+   */ return(output) {
+        this.halted = true;
+        this.output = output;
+    }
+    /**
+   * Halt as reverted
+   * Output data must NOT be modified once it is set
+   * @param output
+   */ revert(output) {
+        this.halted = true;
+        this.reverted = true;
+        this.output = output;
+    }
+    getHalted() {
+        return this.halted;
+    }
+    getReverted() {
+        return this.reverted;
+    }
+    getOutput() {
+        return this.output;
+    }
+    /**
+   * Flag an exceptional halt. Clears gas left and sets the reverted flag. No output data.
+   */ exceptionalHalt() {
+        this.l2GasLeft = 0;
+        this.daGasLeft = 0;
+        this.reverted = true;
+        this.halted = true;
+    }
+}

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

@@ -0,0 +1,264 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger } from '@aztec/foundation/log';
+import type { FunctionsOf } from '@aztec/foundation/types';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/** MemoryValue gathers the common operations for all memory types. */
+export declare abstract class MemoryValue {
+    abstract add(rhs: MemoryValue): MemoryValue;
+    abstract sub(rhs: MemoryValue): MemoryValue;
+    abstract mul(rhs: MemoryValue): MemoryValue;
+    abstract div(rhs: MemoryValue): MemoryValue;
+    abstract equals(rhs: MemoryValue): boolean;
+    abstract lt(rhs: MemoryValue): boolean;
+    abstract build(n: bigint): MemoryValue;
+    abstract toBigInt(): bigint;
+    abstract toBuffer(): Buffer;
+    toFr(): Fr;
+    toAztecAddress(): AztecAddress;
+    toNumber(): number;
+    toString(): string;
+}
+/** IntegralValue gathers the common operations for all integral memory types. */
+export declare abstract class IntegralValue extends MemoryValue {
+    abstract shl(rhs: IntegralValue): IntegralValue;
+    abstract shr(rhs: IntegralValue): IntegralValue;
+    abstract and(rhs: IntegralValue): IntegralValue;
+    abstract or(rhs: IntegralValue): IntegralValue;
+    abstract xor(rhs: IntegralValue): IntegralValue;
+    abstract not(): IntegralValue;
+}
+declare const Uint1_base: {
+    new (n: number | bigint): {
+        readonly n: bigint;
+        build(n: bigint): any;
+        add(rhs: any): any;
+        sub(rhs: any): any;
+        mul(rhs: any): any;
+        div(rhs: any): any;
+        shr(rhs: any): any;
+        shl(rhs: any): any;
+        and(rhs: any): any;
+        or(rhs: any): any;
+        xor(rhs: any): any;
+        not(): any;
+        equals(rhs: any): boolean;
+        lt(rhs: any): boolean;
+        toBigInt(): bigint;
+        toBuffer(): Buffer;
+        toFr(): Fr;
+        toAztecAddress(): AztecAddress;
+        toNumber(): number;
+        toString(): string;
+    };
+    readonly mod: bigint;
+    readonly bitmask: bigint;
+};
+export declare class Uint1 extends Uint1_base {
+}
+declare const Uint8_base: {
+    new (n: number | bigint): {
+        readonly n: bigint;
+        build(n: bigint): any;
+        add(rhs: any): any;
+        sub(rhs: any): any;
+        mul(rhs: any): any;
+        div(rhs: any): any;
+        shr(rhs: any): any;
+        shl(rhs: any): any;
+        and(rhs: any): any;
+        or(rhs: any): any;
+        xor(rhs: any): any;
+        not(): any;
+        equals(rhs: any): boolean;
+        lt(rhs: any): boolean;
+        toBigInt(): bigint;
+        toBuffer(): Buffer;
+        toFr(): Fr;
+        toAztecAddress(): AztecAddress;
+        toNumber(): number;
+        toString(): string;
+    };
+    readonly mod: bigint;
+    readonly bitmask: bigint;
+};
+export declare class Uint8 extends Uint8_base {
+}
+declare const Uint16_base: {
+    new (n: number | bigint): {
+        readonly n: bigint;
+        build(n: bigint): any;
+        add(rhs: any): any;
+        sub(rhs: any): any;
+        mul(rhs: any): any;
+        div(rhs: any): any;
+        shr(rhs: any): any;
+        shl(rhs: any): any;
+        and(rhs: any): any;
+        or(rhs: any): any;
+        xor(rhs: any): any;
+        not(): any;
+        equals(rhs: any): boolean;
+        lt(rhs: any): boolean;
+        toBigInt(): bigint;
+        toBuffer(): Buffer;
+        toFr(): Fr;
+        toAztecAddress(): AztecAddress;
+        toNumber(): number;
+        toString(): string;
+    };
+    readonly mod: bigint;
+    readonly bitmask: bigint;
+};
+export declare class Uint16 extends Uint16_base {
+}
+declare const Uint32_base: {
+    new (n: number | bigint): {
+        readonly n: bigint;
+        build(n: bigint): any;
+        add(rhs: any): any;
+        sub(rhs: any): any;
+        mul(rhs: any): any;
+        div(rhs: any): any;
+        shr(rhs: any): any;
+        shl(rhs: any): any;
+        and(rhs: any): any;
+        or(rhs: any): any;
+        xor(rhs: any): any;
+        not(): any;
+        equals(rhs: any): boolean;
+        lt(rhs: any): boolean;
+        toBigInt(): bigint;
+        toBuffer(): Buffer;
+        toFr(): Fr;
+        toAztecAddress(): AztecAddress;
+        toNumber(): number;
+        toString(): string;
+    };
+    readonly mod: bigint;
+    readonly bitmask: bigint;
+};
+export declare class Uint32 extends Uint32_base {
+}
+declare const Uint64_base: {
+    new (n: number | bigint): {
+        readonly n: bigint;
+        build(n: bigint): any;
+        add(rhs: any): any;
+        sub(rhs: any): any;
+        mul(rhs: any): any;
+        div(rhs: any): any;
+        shr(rhs: any): any;
+        shl(rhs: any): any;
+        and(rhs: any): any;
+        or(rhs: any): any;
+        xor(rhs: any): any;
+        not(): any;
+        equals(rhs: any): boolean;
+        lt(rhs: any): boolean;
+        toBigInt(): bigint;
+        toBuffer(): Buffer;
+        toFr(): Fr;
+        toAztecAddress(): AztecAddress;
+        toNumber(): number;
+        toString(): string;
+    };
+    readonly mod: bigint;
+    readonly bitmask: bigint;
+};
+export declare class Uint64 extends Uint64_base {
+}
+declare const Uint128_base: {
+    new (n: number | bigint): {
+        readonly n: bigint;
+        build(n: bigint): any;
+        add(rhs: any): any;
+        sub(rhs: any): any;
+        mul(rhs: any): any;
+        div(rhs: any): any;
+        shr(rhs: any): any;
+        shl(rhs: any): any;
+        and(rhs: any): any;
+        or(rhs: any): any;
+        xor(rhs: any): any;
+        not(): any;
+        equals(rhs: any): boolean;
+        lt(rhs: any): boolean;
+        toBigInt(): bigint;
+        toBuffer(): Buffer;
+        toFr(): Fr;
+        toAztecAddress(): AztecAddress;
+        toNumber(): number;
+        toString(): string;
+    };
+    readonly mod: bigint;
+    readonly bitmask: bigint;
+};
+export declare class Uint128 extends Uint128_base {
+}
+export declare class Field extends MemoryValue {
+    static readonly MODULUS: bigint;
+    private readonly rep;
+    constructor(v: number | bigint | Fr | Buffer);
+    build(n: bigint): Field;
+    add(rhs: Field): Field;
+    sub(rhs: Field): Field;
+    mul(rhs: Field): Field;
+    div(rhs: Field): Field;
+    fdiv(rhs: Field): Field;
+    equals(rhs: Field): boolean;
+    lt(rhs: Field): boolean;
+    toBigInt(): bigint;
+    toBuffer(): Buffer;
+}
+export declare enum TypeTag {
+    FIELD = 0,
+    UINT1 = 1,
+    UINT8 = 2,
+    UINT16 = 3,
+    UINT32 = 4,
+    UINT64 = 5,
+    UINT128 = 6,
+    INVALID = 7
+}
+export type TaggedMemoryInterface = FunctionsOf<TaggedMemory>;
+export declare class TaggedMemory implements TaggedMemoryInterface {
+    static readonly log: Logger;
+    static readonly TRACK_MEMORY_ACCESSES: boolean;
+    static readonly MAX_MEMORY_SIZE: number;
+    private _mem;
+    constructor();
+    getMaxMemorySize(): number;
+    get(offset: number): MemoryValue;
+    getAs<T>(offset: number): T;
+    getSlice(offset: number, size: number): MemoryValue[];
+    getSliceAs<T>(offset: number, size: number): T[];
+    getSliceTags(offset: number, size: number): TypeTag[];
+    set(offset: number, v: MemoryValue): void;
+    setSlice(offset: number, slice: MemoryValue[]): void;
+    getTag(offset: number): TypeTag;
+    /**
+     * Check that the memory at the given offset matches the specified tag.
+     */
+    checkTag(tag: TypeTag, offset: number): void;
+    checkIsValidMemoryOffsetTag(offset: number): void;
+    static checkIsIntegralTag(tag: TypeTag): void;
+    static checkIsValidTag(tagNumber: number): void;
+    /**
+     * Check tags for memory at all of the specified offsets.
+     */
+    checkTags(tag: TypeTag, ...offsets: number[]): void;
+    /**
+     * Check that all tags at the given offsets are the same.
+     */
+    checkTagsAreSame(offset0: number, offset1: number): void;
+    /**
+     * Check tags for all memory in the specified range.
+     */
+    checkTagsRange(tag: TypeTag, startOffset: number, size: number): void;
+    static getTag(v: MemoryValue | undefined): TypeTag;
+    static buildFromTagTruncating(v: bigint | number, tag: TypeTag): MemoryValue;
+}
+export {};
+//# sourceMappingURL=avm_memory_types.d.ts.map

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

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