@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/public/avm/avm_memory_types.js

@@ -0,0 +1,340 @@
+import { MEM_TAG_FF, MEM_TAG_U1, MEM_TAG_U8, MEM_TAG_U16, MEM_TAG_U32, MEM_TAG_U64, MEM_TAG_U128 } from '@aztec/constants';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { strict as assert } from 'assert';
+import { InvalidTagValueError, MemorySliceOutOfRangeError, TagCheckError } from './errors.js';
+/** MemoryValue gathers the common operations for all memory types. */ export class MemoryValue {
+    // To field
+    toFr() {
+        return new Fr(this.toBigInt());
+    }
+    toAztecAddress() {
+        return new AztecAddress(this.toFr());
+    }
+    // To number. Throws if exceeds max safe int.
+    toNumber() {
+        return this.toFr().toNumber();
+    }
+    toString() {
+        return `${this.constructor.name}(0x${this.toBigInt().toString(16)})`;
+    }
+}
+/** IntegralValue gathers the common operations for all integral memory types. */ export class IntegralValue extends MemoryValue {
+}
+/**
+ * This function creates a class for unsigned integers of a given number of bits.
+ * In TypeScript terms, it's a class mixin.
+ **/ function UnsignedIntegerClassFactory(bits) {
+    return class NewUintClass extends IntegralValue {
+        static mod = 1n << BigInt(bits);
+        static bitmask = this.mod - 1n;
+        n;
+        constructor(n){
+            super();
+            this.n = BigInt(n);
+            assert(n < NewUintClass.mod, `Value ${n} is too large for ${this.constructor.name}.`);
+        }
+        build(n) {
+            return new this.constructor.prototype.constructor(n);
+        }
+        add(rhs) {
+            return this.build(this.n + rhs.n & NewUintClass.bitmask);
+        }
+        sub(rhs) {
+            const res = this.n - rhs.n;
+            return this.build(res >= 0 ? res : res + NewUintClass.mod);
+        }
+        mul(rhs) {
+            return this.build(this.n * rhs.n & NewUintClass.bitmask);
+        }
+        div(rhs) {
+            return this.build(this.n / rhs.n);
+        }
+        // No sign extension.
+        shr(rhs) {
+            // Note that this.n is > 0 by class invariant.
+            return this.build(this.n >> rhs.n);
+        }
+        shl(rhs) {
+            return this.build(this.n << rhs.n & NewUintClass.bitmask);
+        }
+        and(rhs) {
+            return this.build(this.n & rhs.n);
+        }
+        or(rhs) {
+            return this.build(this.n | rhs.n);
+        }
+        xor(rhs) {
+            return this.build(this.n ^ rhs.n);
+        }
+        not() {
+            return this.build(~this.n & NewUintClass.bitmask);
+        }
+        equals(rhs) {
+            return this.n === rhs.n;
+        }
+        lt(rhs) {
+            return this.n < rhs.n;
+        }
+        toBigInt() {
+            return this.n;
+        }
+        toBuffer() {
+            if (bits < 8) {
+                return toBufferBE(this.n, 1);
+            }
+            return toBufferBE(this.n, bits / 8);
+        }
+    };
+}
+// Now we can create the classes for each unsigned integer type.
+// We extend instead of just assigning so that the class has the right name.
+// Otherwise they are all called "NewUintClass".
+export class Uint1 extends UnsignedIntegerClassFactory(1) {
+}
+export class Uint8 extends UnsignedIntegerClassFactory(8) {
+}
+export class Uint16 extends UnsignedIntegerClassFactory(16) {
+}
+export class Uint32 extends UnsignedIntegerClassFactory(32) {
+}
+export class Uint64 extends UnsignedIntegerClassFactory(64) {
+}
+export class Uint128 extends UnsignedIntegerClassFactory(128) {
+}
+export class Field extends MemoryValue {
+    static MODULUS = Fr.MODULUS;
+    rep;
+    constructor(v){
+        super();
+        this.rep = new Fr(v);
+    }
+    build(n) {
+        return new Field(n);
+    }
+    add(rhs) {
+        return new Field(this.rep.add(rhs.rep));
+    }
+    sub(rhs) {
+        return new Field(this.rep.sub(rhs.rep));
+    }
+    mul(rhs) {
+        return new Field(this.rep.mul(rhs.rep));
+    }
+    // Euclidean division.
+    div(rhs) {
+        return new Field(this.rep.ediv(rhs.rep));
+    }
+    // Field division.
+    fdiv(rhs) {
+        return new Field(this.rep.div(rhs.rep));
+    }
+    equals(rhs) {
+        return this.rep.equals(rhs.rep);
+    }
+    lt(rhs) {
+        return this.rep.lt(rhs.rep);
+    }
+    toBigInt() {
+        return this.rep.toBigInt();
+    }
+    toBuffer() {
+        return this.rep.toBuffer();
+    }
+}
+export var TypeTag = /*#__PURE__*/ function(TypeTag) {
+    TypeTag[TypeTag["FIELD"] = MEM_TAG_FF] = "FIELD";
+    TypeTag[TypeTag["UINT1"] = MEM_TAG_U1] = "UINT1";
+    TypeTag[TypeTag["UINT8"] = MEM_TAG_U8] = "UINT8";
+    TypeTag[TypeTag["UINT16"] = MEM_TAG_U16] = "UINT16";
+    TypeTag[TypeTag["UINT32"] = MEM_TAG_U32] = "UINT32";
+    TypeTag[TypeTag["UINT64"] = MEM_TAG_U64] = "UINT64";
+    TypeTag[TypeTag["UINT128"] = MEM_TAG_U128] = "UINT128";
+    TypeTag[TypeTag["INVALID"] = MEM_TAG_U128 + 1] = "INVALID";
+    return TypeTag;
+}({});
+export class TaggedMemory {
+    static log = createLogger('simulator:avm:memory');
+    // Whether to track and validate memory accesses for each instruction.
+    static TRACK_MEMORY_ACCESSES = process.env.NODE_ENV === 'test';
+    // Memory is modelled by a map with key type being number.
+    // We however restrict the keys to be non-negative integers smaller than
+    // MAX_MEMORY_SIZE.
+    static MAX_MEMORY_SIZE = Number(1n << 32n);
+    _mem;
+    constructor(){
+        this._mem = new Map();
+    }
+    getMaxMemorySize() {
+        return TaggedMemory.MAX_MEMORY_SIZE;
+    }
+    get(offset) {
+        return this.getAs(offset);
+    }
+    getAs(offset) {
+        assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
+        const word = this._mem.get(offset);
+        //TaggedMemory.log.trace(`get(${offset}) = ${word}`);
+        if (word === undefined) {
+            TaggedMemory.log.debug(`WARNING: Memory at offset ${offset} is undefined!`);
+            return new Field(0);
+        }
+        return word;
+    }
+    getSlice(offset, size) {
+        assert(Number.isInteger(offset) && Number.isInteger(size));
+        if (offset + size > TaggedMemory.MAX_MEMORY_SIZE) {
+            throw new MemorySliceOutOfRangeError(offset, size);
+        }
+        const slice = new Array(size);
+        for(let i = 0; i < size; i++){
+            slice[i] = this._mem.get(offset + i) ?? new Field(0);
+        }
+        TaggedMemory.log.trace(`getSlice(${offset}, ${size}) = ${slice}`);
+        return slice;
+    }
+    getSliceAs(offset, size) {
+        return this.getSlice(offset, size);
+    }
+    getSliceTags(offset, size) {
+        return this.getSlice(offset, size).map(TaggedMemory.getTag);
+    }
+    set(offset, v) {
+        assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
+        this._mem.set(offset, v);
+    //TaggedMemory.log.trace(`set(${offset}, ${v})`);
+    }
+    setSlice(offset, slice) {
+        assert(Number.isInteger(offset));
+        if (offset + slice.length > TaggedMemory.MAX_MEMORY_SIZE) {
+            throw new MemorySliceOutOfRangeError(offset, slice.length);
+        }
+        slice.forEach((element, idx)=>{
+            this._mem.set(offset + idx, element);
+        });
+        TaggedMemory.log.trace(`setSlice(${offset}, ${slice})`);
+    }
+    getTag(offset) {
+        assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
+        return TaggedMemory.getTag(this._mem.get(offset));
+    }
+    /**
+   * Check that the memory at the given offset matches the specified tag.
+   */ checkTag(tag, offset) {
+        const gotTag = this.getTag(offset);
+        if (gotTag !== tag) {
+            throw TagCheckError.forOffset(offset, TypeTag[gotTag], TypeTag[tag]);
+        }
+    }
+    checkIsValidMemoryOffsetTag(offset) {
+        this.checkTag(TypeTag.UINT32, offset);
+    }
+    static checkIsIntegralTag(tag) {
+        if (!INTEGRAL_TAGS.has(tag)) {
+            throw TagCheckError.forTag(TypeTag[tag], 'integral');
+        }
+    }
+    static checkIsValidTag(tagNumber) {
+        if (!VALID_TAGS.has(tagNumber)) {
+            throw new InvalidTagValueError(tagNumber);
+        }
+    }
+    /**
+   * Check tags for memory at all of the specified offsets.
+   */ checkTags(tag, ...offsets) {
+        for (const offset of offsets){
+            this.checkTag(tag, offset);
+        }
+    }
+    /**
+   * Check that all tags at the given offsets are the same.
+   */ checkTagsAreSame(offset0, offset1) {
+        const tag0 = this.getTag(offset0);
+        this.checkTag(tag0, offset1);
+    }
+    /**
+   * Check tags for all memory in the specified range.
+   */ checkTagsRange(tag, startOffset, size) {
+        for(let offset = startOffset; offset < startOffset + size; offset++){
+            this.checkTag(tag, offset);
+        }
+    }
+    static getTag(v) {
+        if (v === undefined) {
+            return TypeTag.FIELD; // uninitialized memory is Field(0)
+        } else {
+            return TAG_FOR_MEM_VAL.get(v.constructor.name) ?? TypeTag.INVALID;
+        }
+    }
+    // Truncates the value to fit the type.
+    static buildFromTagTruncating(v, tag) {
+        v = BigInt(v);
+        switch(tag){
+            case TypeTag.FIELD:
+                return new Field(v);
+            case TypeTag.UINT1:
+                return new Uint1(v & 1n);
+            case TypeTag.UINT8:
+                return new Uint8(v & (1n << 8n) - 1n);
+            case TypeTag.UINT16:
+                return new Uint16(v & (1n << 16n) - 1n);
+            case TypeTag.UINT32:
+                return new Uint32(v & (1n << 32n) - 1n);
+            case TypeTag.UINT64:
+                return new Uint64(v & (1n << 64n) - 1n);
+            case TypeTag.UINT128:
+                return new Uint128(v & (1n << 128n) - 1n);
+            default:
+                throw new InvalidTagValueError(tag);
+        }
+    }
+}
+const TAG_FOR_MEM_VAL = new Map([
+    [
+        'Field',
+        TypeTag.FIELD
+    ],
+    [
+        'Uint1',
+        TypeTag.UINT1
+    ],
+    [
+        'Uint8',
+        TypeTag.UINT8
+    ],
+    [
+        'Uint16',
+        TypeTag.UINT16
+    ],
+    [
+        'Uint32',
+        TypeTag.UINT32
+    ],
+    [
+        'Uint64',
+        TypeTag.UINT64
+    ],
+    [
+        'Uint128',
+        TypeTag.UINT128
+    ]
+]);
+const VALID_TAGS = new Set([
+    TypeTag.FIELD,
+    TypeTag.UINT1,
+    TypeTag.UINT8,
+    TypeTag.UINT16,
+    TypeTag.UINT32,
+    TypeTag.UINT64,
+    TypeTag.UINT128
+]);
+const INTEGRAL_TAGS = new Set([
+    TypeTag.UINT1,
+    TypeTag.UINT8,
+    TypeTag.UINT16,
+    TypeTag.UINT32,
+    TypeTag.UINT64,
+    TypeTag.UINT128
+]);

package/dest/{avm → public/avm}/avm_simulator.d.ts

@@ -1,10 +1,12 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type AztecAddress, Fr, type GlobalVariables } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
 import { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
-import { type Gas } from './avm_gas.js';
-import { type AvmPersistableStateManager } from './journal/journal.js';
+import type { Gas } from './avm_gas.js';
+import type { AvmPersistableStateManager } from './journal/journal.js';
 import { type InstructionSet } from './serialization/bytecode_serialization.js';
 export declare class AvmSimulator {
     private context;

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

@@ -0,0 +1 @@
+{"version":3,"file":"avm_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/avm/avm_simulator.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKxD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAUxC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAEvE,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,2CAA2C,CAAC;AAOnD,qBAAa,YAAY;IAarB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,cAAc;IAbxB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,aAAa,CAAuC;IAE5D,OAAO,CAAC,6BAA6B,CAAiD;IAEtF,OAAO,CAAC,kBAAkB,CAAY;IACtC,OAAO,CAAC,wBAAwB,CAA+B;gBAKrD,OAAO,EAAE,UAAU,EACnB,cAAc,GAAE,cAAgC,EACxD,cAAc,UAAQ;WAmBJ,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;WAQjD,MAAM,CACxB,YAAY,EAAE,0BAA0B,EACxC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,YAAY,EACpB,cAAc,EAAE,EAAE,EAClB,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,EAAE,EAAE,EACd,YAAY,EAAE,GAAG;IAiBnB;;OAEG;IACU,OAAO,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAuBtD;;OAEG;IACI,WAAW,IAAI,MAAM,GAAG,SAAS;IAIxC;;;OAGG;IACU,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;YA2GhE,+BAA+B;IAoB7C,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,kBAAkB;CAS3B"}

package/dest/public/avm/avm_simulator.js

@@ -0,0 +1,202 @@
+import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { strict as assert } from 'assert';
+import { SideEffectLimitReachedError } from '../side_effect_errors.js';
+import { AvmContext } from './avm_context.js';
+import { AvmContractCallResult } from './avm_contract_call_result.js';
+import { AvmExecutionEnvironment } from './avm_execution_environment.js';
+import { AvmMachineState } from './avm_machine_state.js';
+import { isAvmBytecode } from './bytecode_utils.js';
+import { AvmExecutionError, AvmRevertReason, InvalidProgramCounterError, revertReasonFromExceptionalHalt, revertReasonFromExplicitRevert } from './errors.js';
+import { INSTRUCTION_SET, decodeInstructionFromBytecode } from './serialization/bytecode_serialization.js';
+export class AvmSimulator {
+    context;
+    instructionSet;
+    log;
+    bytecode;
+    opcodeTallies;
+    // maps pc to [instr, bytesRead]
+    deserializedInstructionsCache;
+    tallyPrintFunction;
+    tallyInstructionFunction;
+    // Test Purposes only: Logger will not have the proper function name. Use this constructor for testing purposes
+    // only. Otherwise, use build() below.
+    constructor(context, instructionSet = INSTRUCTION_SET, enableTallying = false){
+        this.context = context;
+        this.instructionSet = instructionSet;
+        this.opcodeTallies = new Map();
+        this.deserializedInstructionsCache = new Map();
+        this.tallyPrintFunction = ()=>{};
+        this.tallyInstructionFunction = (_b, _c)=>{};
+        // This will be used by the CALL opcode to create a new simulator. It is required to
+        // avoid a dependency cycle.
+        context.provideSimulator = AvmSimulator.build;
+        assert(context.machineState.gasLeft.l2Gas <= MAX_L2_GAS_PER_TX_PUBLIC_PORTION, `Cannot allocate more than ${MAX_L2_GAS_PER_TX_PUBLIC_PORTION} to the AVM for execution.`);
+        this.log = createLogger(`simulator:avm(calldata[0]: ${context.environment.calldata[0]})`);
+        // Turn on tallying if explicitly enabled or if trace logging
+        if (enableTallying || this.log.isLevelEnabled('trace')) {
+            this.tallyPrintFunction = this.printOpcodeTallies;
+            this.tallyInstructionFunction = this.tallyInstruction;
+        }
+    }
+    // Factory to have a proper function name in the logger. Retrieving the name is asynchronous and
+    // cannot be done as part of the constructor.
+    static async build(context) {
+        const simulator = new AvmSimulator(context);
+        const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
+        simulator.log = createLogger(`simulator:avm(f:${fnName})`);
+        return simulator;
+    }
+    static async create(stateManager, address, sender, transactionFee, globals, isStaticCall, calldata, allocatedGas) {
+        const avmExecutionEnv = new AvmExecutionEnvironment(address, sender, /*contractCallDepth=*/ Fr.zero(), transactionFee, globals, isStaticCall, calldata);
+        const avmMachineState = new AvmMachineState(allocatedGas);
+        const avmContext = new AvmContext(stateManager, avmExecutionEnv, avmMachineState);
+        return await AvmSimulator.build(avmContext);
+    }
+    /**
+   * Fetch the bytecode and execute it in the current context.
+   */ async execute() {
+        let bytecode;
+        try {
+            bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
+        } catch (err) {
+            if (!(err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
+                this.log.error(`Unknown error thrown by AVM during bytecode retrieval: ${err}`);
+                throw err;
+            }
+            return await this.handleFailureToRetrieveBytecode(`Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err}. Reverting...`);
+        }
+        if (!bytecode) {
+            return await this.handleFailureToRetrieveBytecode(`No bytecode found at: ${this.context.environment.address}. Reverting...`);
+        }
+        return await this.executeBytecode(bytecode);
+    }
+    /**
+   * Return the bytecode used for execution, if any.
+   */ getBytecode() {
+        return this.bytecode;
+    }
+    /**
+   * Executes the provided bytecode in the current context.
+   * This method is useful for testing and debugging.
+   */ async executeBytecode(bytecode) {
+        const startTotalTime = performance.now();
+        assert(isAvmBytecode(bytecode), "AVM simulator can't execute non-AVM bytecode");
+        assert(bytecode.length > 0, "AVM simulator can't execute empty bytecode");
+        this.bytecode = bytecode;
+        const { machineState } = this.context;
+        const callStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
+        try {
+            // Execute instruction pointed to by the current program counter
+            // continuing until the machine state signifies a halt
+            let instrCounter = 0;
+            while(!machineState.getHalted()){
+                // Get the instruction from cache, or deserialize for the first time
+                let cachedInstruction = this.deserializedInstructionsCache.get(machineState.pc);
+                if (cachedInstruction === undefined) {
+                    cachedInstruction = decodeInstructionFromBytecode(bytecode, machineState.pc, this.instructionSet);
+                    this.deserializedInstructionsCache.set(machineState.pc, cachedInstruction);
+                }
+                const [instruction, bytesRead] = cachedInstruction;
+                const instrStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
+                if (this.log.isLevelEnabled('trace')) {
+                    // Skip this entirely to avoid toStringing etc if trace is not enabled
+                    this.log.trace(`[PC:${machineState.pc}] [IC:${instrCounter}] ${instruction.toString()} (gasLeft l2=${machineState.l2GasLeft} da=${machineState.daGasLeft})`);
+                }
+                instrCounter++;
+                machineState.nextPc = machineState.pc + bytesRead;
+                // Execute the instruction.
+                // Normal returns and reverts will return normally here.
+                // "Exceptional halts" will throw.
+                await instruction.execute(this.context);
+                if (!instruction.handlesPC()) {
+                    // Increment PC if the instruction doesn't handle it itself
+                    machineState.pc += bytesRead;
+                }
+                // gas used by this instruction - used for profiling/tallying
+                const gasUsed = {
+                    l2Gas: instrStartGas.l2Gas - machineState.l2GasLeft,
+                    daGas: instrStartGas.daGas - machineState.daGasLeft
+                };
+                this.tallyInstructionFunction(instruction.constructor.name, gasUsed);
+                if (machineState.pc >= bytecode.length) {
+                    this.log.warn('Passed end of program');
+                    throw new InvalidProgramCounterError(machineState.pc, /*max=*/ bytecode.length);
+                }
+            }
+            const output = machineState.getOutput();
+            const reverted = machineState.getReverted();
+            const revertReason = reverted ? await revertReasonFromExplicitRevert(output, this.context) : undefined;
+            const results = new AvmContractCallResult(reverted, output, machineState.gasLeft, revertReason);
+            this.log.debug(`Context execution results: ${results.toString()}`);
+            const totalGasUsed = {
+                l2Gas: callStartGas.l2Gas - machineState.l2GasLeft,
+                daGas: callStartGas.daGas - machineState.daGasLeft
+            };
+            this.log.debug(`Executed ${instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
+            this.tallyPrintFunction();
+            const endTotalTime = performance.now();
+            const totalTime = endTotalTime - startTotalTime;
+            this.log.debug(`Core AVM simulation took ${totalTime}ms`);
+            // Return results for processing by calling context
+            return results;
+        } catch (err) {
+            this.log.verbose('Exceptional halt (revert by something other than REVERT opcode)');
+            // FIXME: weird that we have to do this OutOfGasError check because:
+            // 1. OutOfGasError is an AvmExecutionError, so that check should cover both
+            // 2. We should at least be able to do instanceof OutOfGasError instead of checking the constructor name
+            if (!(err.constructor.name == 'OutOfGasError' || err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
+                this.log.error(`Unknown error thrown by AVM: ${err}`);
+                throw err;
+            }
+            const revertReason = await revertReasonFromExceptionalHalt(err, this.context);
+            // Exceptional halts consume all allocated gas
+            const noGasLeft = {
+                l2Gas: 0,
+                daGas: 0
+            };
+            // Note: "exceptional halts" cannot return data, hence [].
+            const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], noGasLeft, revertReason);
+            this.log.debug(`Context execution results: ${results.toString()}`);
+            this.tallyPrintFunction();
+            // Return results for processing by calling context
+            return results;
+        }
+    }
+    async handleFailureToRetrieveBytecode(message) {
+        // revert, consuming all gas
+        const fnName = await this.context.persistableState.getPublicFunctionDebugName(this.context.environment);
+        const revertReason = new AvmRevertReason(message, /*failingFunction=*/ {
+            contractAddress: this.context.environment.address,
+            functionName: fnName
+        }, /*noirCallStack=*/ []);
+        this.log.warn(message);
+        return new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], /*gasLeft=*/ {
+            l2Gas: 0,
+            daGas: 0
+        }, revertReason);
+    }
+    tallyInstruction(opcode, gasUsed) {
+        const opcodeTally = this.opcodeTallies.get(opcode) || {
+            count: 0,
+            gas: {
+                l2Gas: 0,
+                daGas: 0
+            }
+        };
+        opcodeTally.count++;
+        opcodeTally.gas.l2Gas += gasUsed.l2Gas;
+        opcodeTally.gas.daGas += gasUsed.daGas;
+        this.opcodeTallies.set(opcode, opcodeTally);
+    }
+    printOpcodeTallies() {
+        this.log.debug(`Printing tallies per opcode sorted by gas...`);
+        // sort descending by L2 gas consumed
+        const sortedOpcodes = Array.from(this.opcodeTallies.entries()).sort((a, b)=>b[1].gas.l2Gas - a[1].gas.l2Gas);
+        for (const [opcode, tally] of sortedOpcodes){
+            // NOTE: don't care to clutter the logs with DA gas for now
+            this.log.debug(`${opcode} executed ${tally.count} times consuming a total of ${tally.gas.l2Gas} L2 gas`);
+        }
+    }
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"bytecode_utils.d.ts","sourceRoot":"","sources":["../../../src/public/avm/bytecode_utils.ts"],"names":[],"mappings":";;AASA,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGvD"}

package/dest/public/avm/bytecode_utils.js

@@ -0,0 +1,17 @@
+import { Opcode } from './serialization/instruction_serialization.js';
+const AVM_MAGIC_SUFFIX = Buffer.from([
+    Opcode.MOV_16,
+    0x00,
+    ...Buffer.from('18ca', 'hex'),
+    ...Buffer.from('18ca', 'hex')
+]);
+export function markBytecodeAsAvm(bytecode) {
+    return Buffer.concat([
+        bytecode,
+        AVM_MAGIC_SUFFIX
+    ]);
+}
+export function isAvmBytecode(bytecode) {
+    const magicSize = AVM_MAGIC_SUFFIX.length;
+    return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+}

package/dest/{avm → public/avm}/errors.d.ts

@@ -1,7 +1,8 @@
-import { type FailingFunction, type NoirCallStack } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr, type Point } from '@aztec/circuits.js';
-import { ExecutionError } from '../common/errors.js';
-import { type AvmContext } from './avm_context.js';
+import type { Fr, Point } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
+import { ExecutionError } from '../../common/errors.js';
+import type { AvmContext } from './avm_context.js';
 /**
  * Avm-specific errors should derive from this
  */

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/public/avm/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;GAEG;AACH,8BAAsB,iBAAkB,SAAQ,KAAK;gBACvC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,0BAA2B,SAAQ,iBAAiB;gBACnD,eAAe,EAAE,YAAY;CAI1C;AAED,qBAAa,eAAgB,SAAQ,iBAAiB;gBACxC,OAAO,EAAE,MAAM;CAI5B;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,iBAAiB;gBACnD,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;CAIpC;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,iBAAiB;gBAC3C,GAAG,EAAE,MAAM;CAIxB;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,iBAAiB;gBACxC,GAAG,EAAE,MAAM;CAIxB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,iBAAiB;gBAC7C,QAAQ,EAAE,MAAM;CAI7B;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,iBAAiB;gBAClD,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,iBAAiB;WACpC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa;WAI7E,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa;gBAI5D,OAAO,EAAE,MAAM;CAI5B;AAED;;;GAGG;AACH,qBAAa,8BAA+B,SAAQ,iBAAiB;gBACvD,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAIhD;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,iBAAiB;gBACnD,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAI3C;AAED,oCAAoC;AACpC,qBAAa,aAAc,SAAQ,iBAAiB;gBACtC,UAAU,EAAE,MAAM,EAAE;CAIjC;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,iBAAiB;gBAC7C,gBAAgB,EAAE,MAAM;CAIrC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,iBAAiB;gBAChD,KAAK,EAAE,KAAK;CAIzB;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,iBAAiB;gBAClD,WAAW,EAAE,MAAM;CAIhC;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,yBAAyB;;CAKvE;AAED;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,cAAc;gBACrC,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,YAAY;CAGpH;AA8BD;;;;;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"}