@feelyourprotocol/evm 8141.0.0

package/dist/esm/evm.js

@@ -0,0 +1,1131 @@
+import { Hardfork } from '@feelyourprotocol/common';
+import { Account, Address, BIGINT_0, BIGINT_1, EthereumJSErrorWithoutCode, KECCAK256_NULL, KECCAK256_RLP, MAX_INTEGER, bigIntToBytes, bytesToUnprefixedHex, createBlockLevelAccessList, createZeroAddress, equalsBytes, generateAddress, generateAddress2, isDebugEnabled, short, } from '@feelyourprotocol/util';
+import debugDefault from 'debug';
+import { EventEmitter } from 'eventemitter3';
+import { createEIP7708TransferLog } from "./eip7708.js";
+import { FORMAT } from "./eof/constants.js";
+import { isEOF } from "./eof/util.js";
+import { EVMError } from "./errors.js";
+import { Interpreter } from "./interpreter.js";
+import { Journal } from "./journal.js";
+import { EVMPerformanceLogger } from "./logger.js";
+import { Message } from "./message.js";
+import { getOpcodesForHF } from "./opcodes/index.js";
+import { paramsEVM } from "./params.js";
+import { NobleBLS, getActivePrecompiles, getPrecompileName } from "./precompiles/index.js";
+import { TransientStorage } from "./transientStorage.js";
+import { DELEGATION_7702_FLAG, } from "./types.js";
+const debug = debugDefault('evm:evm');
+const debugGas = debugDefault('evm:gas');
+const debugPrecompiles = debugDefault('evm:precompiles');
+/**
+ * Creates a standardized ExecResult for out-of-gas errors.
+ * @param gasLimit - Gas limit consumed by the failing frame
+ * @returns Execution result describing the OOG failure
+ */
+export function OOGResult(gasLimit) {
+    return {
+        returnValue: new Uint8Array(0),
+        executionGasUsed: gasLimit,
+        exceptionError: new EVMError(EVMError.errorMessages.OUT_OF_GAS),
+    };
+}
+/**
+ * Creates an ExecResult for code-deposit out-of-gas errors (EIP-3541).
+ * @param gasUsedCreateCode - Gas consumed while attempting to store code
+ */
+export function COOGResult(gasUsedCreateCode) {
+    return {
+        returnValue: new Uint8Array(0),
+        executionGasUsed: gasUsedCreateCode,
+        exceptionError: new EVMError(EVMError.errorMessages.CODESTORE_OUT_OF_GAS),
+    };
+}
+/**
+ * Returns an ExecResult signalling invalid bytecode input.
+ * @param gasLimit - Gas consumed up to the point of failure
+ */
+export function INVALID_BYTECODE_RESULT(gasLimit) {
+    return {
+        returnValue: new Uint8Array(0),
+        executionGasUsed: gasLimit,
+        exceptionError: new EVMError(EVMError.errorMessages.INVALID_BYTECODE_RESULT),
+    };
+}
+/**
+ * Returns an ExecResult signalling invalid EOF formatting.
+ * @param gasLimit - Gas consumed up to the point of failure
+ */
+export function INVALID_EOF_RESULT(gasLimit) {
+    return {
+        returnValue: new Uint8Array(0),
+        executionGasUsed: gasLimit,
+        exceptionError: new EVMError(EVMError.errorMessages.INVALID_EOF_FORMAT),
+    };
+}
+/**
+ * Returns an ExecResult for code size violations.
+ * @param gasUsed - Gas consumed before the violation was detected
+ */
+export function CodesizeExceedsMaximumError(gasUsed) {
+    return {
+        returnValue: new Uint8Array(0),
+        executionGasUsed: gasUsed,
+        exceptionError: new EVMError(EVMError.errorMessages.CODESIZE_EXCEEDS_MAXIMUM),
+    };
+}
+/**
+ * Wraps an {@link EVMError} in an ExecResult.
+ * @param error - Error encountered during execution
+ * @param gasUsed - Gas consumed up to the error
+ */
+export function EVMErrorResult(error, gasUsed) {
+    return {
+        returnValue: new Uint8Array(0),
+        executionGasUsed: gasUsed,
+        exceptionError: error,
+    };
+}
+/**
+ * Creates a default block header used by stand-alone executions.
+ * @returns Block-like object with zeroed header fields
+ */
+export function defaultBlock() {
+    return {
+        header: {
+            number: BIGINT_0,
+            coinbase: createZeroAddress(),
+            timestamp: BIGINT_0,
+            difficulty: BIGINT_0,
+            prevRandao: new Uint8Array(32),
+            gasLimit: BIGINT_0,
+            baseFeePerGas: undefined,
+            getBlobGasPrice: () => undefined,
+        },
+    };
+}
+/**
+ * The EVM (Ethereum Virtual Machine) is responsible for executing EVM bytecode, processing transactions, and managing state changes. It handles both contract calls and contract creation operations.
+ *
+ * An EVM instance can be created with the constructor method:
+ *
+ * - {@link createEVM}
+ */
+export class EVM {
+    get precompiles() {
+        return this._precompiles;
+    }
+    get opcodes() {
+        return this._opcodes;
+    }
+    /**
+     *
+     * Creates new EVM object
+     *
+     * @deprecated The direct usage of this constructor is replaced since
+     * non-finalized async initialization lead to side effects. Please
+     * use the async {@link createEVM} constructor instead (same API).
+     *
+     * @param opts The EVM options
+     * @param bn128 Initialized bn128 WASM object for precompile usage (internal)
+     */
+    constructor(opts) {
+        /**
+         * EVM is run in DEBUG mode (default: false)
+         * Taken from DEBUG environment variable
+         *
+         * Safeguards on debug() calls are added for
+         * performance reasons to avoid string literal evaluation
+         * @hidden
+         */
+        this.DEBUG = false;
+        this.common = opts.common;
+        this.blockchain = opts.blockchain;
+        this.stateManager = opts.stateManager;
+        if (this.common.isActivatedEIP(7864)) {
+            const mandatory = ['checkChunkWitnessPresent'];
+            for (const m of mandatory) {
+                if (!(m in this.stateManager)) {
+                    throw EthereumJSErrorWithoutCode(`State manager used must implement ${m} if Binary Trees (EIP-7864) is activated`);
+                }
+            }
+        }
+        if (this.common.isActivatedEIP(7928)) {
+            this.blockLevelAccessList = opts.blockLevelAccessList ?? createBlockLevelAccessList();
+        }
+        this.events = new EventEmitter();
+        this._optsCached = opts;
+        // Supported EIPs
+        const supportedEIPs = [
+            1153, 1559, 2537, 2565, 2718, 2929, 2930, 2935, 3198, 3529, 3540, 3541, 3607, 3651, 3670,
+            3855, 3860, 4200, 4399, 4750, 4788, 4844, 4895, 5133, 5450, 5656, 6110, 6206, 6780, 7002,
+            7069, 7251, 7480, 7516, 7594, 7620, 7685, 7691, 7692, 7698, 7702, 7709, 7823, 7825, 7934,
+            7939, 7951, 8024, 8141,
+        ];
+        for (const eip of this.common.eips()) {
+            if (!supportedEIPs.includes(eip)) {
+                throw EthereumJSErrorWithoutCode(`EIP-${eip} is not supported by the EVM`);
+            }
+        }
+        if (!EVM.supportedHardforks.includes(this.common.hardfork())) {
+            throw EthereumJSErrorWithoutCode(`Hardfork ${this.common.hardfork()} not set as supported in supportedHardforks`);
+        }
+        this.common.updateParams(opts.params ?? paramsEVM);
+        this.allowUnlimitedContractSize = opts.allowUnlimitedContractSize ?? false;
+        this.allowUnlimitedInitCodeSize = opts.allowUnlimitedInitCodeSize ?? false;
+        this._customOpcodes = opts.customOpcodes;
+        this._customPrecompiles = opts.customPrecompiles;
+        this.journal = new Journal(this.stateManager, this.common);
+        this.transientStorage = new TransientStorage();
+        this.common.events.on('hardforkChanged', () => {
+            this.getActiveOpcodes();
+            this._precompiles = getActivePrecompiles(this.common, this._customPrecompiles);
+        });
+        // Initialize the opcode data
+        this.getActiveOpcodes();
+        this._precompiles = getActivePrecompiles(this.common, this._customPrecompiles);
+        // Precompile crypto libraries
+        if (this.common.isActivatedEIP(2537)) {
+            this._bls = opts.bls ?? new NobleBLS();
+            this._bls.init?.();
+        }
+        this._bn254 = opts.bn254;
+        this._emit = async (topic, data) => {
+            const listeners = this.events.listeners(topic);
+            for (const listener of listeners) {
+                if (listener.length === 2) {
+                    await new Promise((resolve) => {
+                        listener(data, resolve);
+                    });
+                }
+                else {
+                    listener(data);
+                }
+            }
+        };
+        this.performanceLogger = new EVMPerformanceLogger();
+        // Skip DEBUG calls unless 'ethjs' included in environmental DEBUG variables
+        this.DEBUG = isDebugEnabled('ethjs');
+    }
+    /**
+     * Returns a list with the currently activated opcodes
+     * available for EVM execution
+     */
+    getActiveOpcodes() {
+        const data = getOpcodesForHF(this.common, this._customOpcodes);
+        this._opcodes = data.opcodes;
+        this._dynamicGasHandlers = data.dynamicGasHandlers;
+        this._handlers = data.handlers;
+        this._opcodeMap = data.opcodeMap;
+        return data.opcodes;
+    }
+    async _executeCall(message) {
+        let gasLimit = message.gasLimit;
+        const fromAddress = message.caller;
+        if (this.common.isActivatedEIP(7864)) {
+            if (message.accessWitness === undefined) {
+                throw EthereumJSErrorWithoutCode('accessWitness is required for EIP-7864');
+            }
+            const sendsValue = message.value !== BIGINT_0;
+            if (message.depth === 0) {
+                const originAccessGas = message.accessWitness.readAccountHeader(fromAddress);
+                debugGas(`originAccessGas=${originAccessGas} waived off for origin at depth=0`);
+                let destAccessGas = message.accessWitness.readAccountCodeHash(message.to);
+                if (sendsValue) {
+                    destAccessGas += message.accessWitness.writeAccountBasicData(message.to);
+                }
+                else {
+                    destAccessGas += message.accessWitness.readAccountBasicData(message.to);
+                }
+                debugGas(`destAccessGas=${destAccessGas} waived off for target at depth=0`);
+            }
+            let callAccessGas = message.accessWitness.readAccountBasicData(message.to);
+            if (sendsValue) {
+                callAccessGas += message.accessWitness.writeAccountBasicData(message.to);
+            }
+            gasLimit -= callAccessGas;
+            if (gasLimit < BIGINT_0) {
+                if (this.DEBUG) {
+                    debugGas(`callAccessGas charged(${callAccessGas}) caused OOG (-> ${gasLimit})`);
+                }
+                message.accessWitness.revert();
+                return { execResult: OOGResult(message.gasLimit) };
+            }
+            else {
+                if (this.DEBUG) {
+                    debugGas(`callAccessGas used (${callAccessGas} gas (-> ${gasLimit}))`);
+                }
+                message.accessWitness.commit();
+            }
+        }
+        let account = await this.stateManager.getAccount(fromAddress);
+        if (!account) {
+            account = new Account();
+        }
+        let errorMessage;
+        // Reduce tx value from sender
+        if (!message.delegatecall) {
+            try {
+                await this._reduceSenderBalance(account, message);
+            }
+            catch (e) {
+                errorMessage = e;
+            }
+        }
+        // Load `to` account
+        let toAccount = await this.stateManager.getAccount(message.to);
+        if (!toAccount) {
+            if (this.common.isActivatedEIP(6800) || this.common.isActivatedEIP(7864)) {
+                const absenceProofAccessGas = message.accessWitness.readAccountHeader(message.to);
+                gasLimit -= absenceProofAccessGas;
+                if (gasLimit < BIGINT_0) {
+                    if (this.DEBUG) {
+                        debugGas(`Proof of absence access charged(${absenceProofAccessGas}) caused OOG (-> ${gasLimit})`);
+                    }
+                    message.accessWitness?.revert();
+                    return { execResult: OOGResult(message.gasLimit) };
+                }
+                else {
+                    if (this.DEBUG) {
+                        debugGas(`Proof of absence access used (${absenceProofAccessGas} gas (-> ${gasLimit}))`);
+                    }
+                    message.accessWitness?.commit();
+                }
+            }
+            toAccount = new Account();
+        }
+        // Add tx value to the `to` account
+        if (!message.delegatecall) {
+            try {
+                await this._addToBalance(toAccount, message);
+            }
+            catch (e) {
+                errorMessage = e;
+            }
+        }
+        // EIP-7928: Add codeAddress to BAL for DELEGATECALL/CALLCODE
+        // For these opcodes, `to` is the current contract but `codeAddress` is the target
+        // whose code is being executed. The target MUST be included in the BAL.
+        if (this.common.isActivatedEIP(7928) &&
+            message.codeAddress !== undefined &&
+            message.codeAddress.toString() !== message.to.toString()) {
+            this.blockLevelAccessList.addAddress(message.codeAddress.toString());
+        }
+        // Load code
+        await this._loadCode(message);
+        let exit = false;
+        if (!message.code || (typeof message.code !== 'function' && message.code.length === 0)) {
+            exit = true;
+            if (this.DEBUG) {
+                debug(`Exit early on no code (CALL)`);
+            }
+        }
+        if (errorMessage !== undefined) {
+            exit = true;
+            if (this.DEBUG) {
+                debug(`Exit early on value transfer overflowed (CALL)`);
+            }
+        }
+        // EIP-7708: Create ETH transfer log for non-zero value transfers to a different account.
+        // CALLCODE always executes in the caller's context (to == caller), so it is a self-transfer.
+        // Self-transfers (caller == to) and DELEGATECALL do not emit a log.
+        let eip7708Log;
+        const isTransferToDifferentAccount = !equalsBytes(message.caller.bytes, message.to.bytes);
+        if (this.common.isActivatedEIP(7708) &&
+            !message.delegatecall &&
+            message.value > BIGINT_0 &&
+            isTransferToDifferentAccount &&
+            errorMessage === undefined) {
+            eip7708Log = createEIP7708TransferLog(message.caller, message.to, message.value);
+            if (this.DEBUG) {
+                debug(`EIP-7708: Created ETH transfer log from ${message.caller} to ${message.to} value=${message.value}`);
+            }
+        }
+        if (exit) {
+            // Even on early exit, we may need to return the EIP-7708 log if value was transferred
+            return {
+                execResult: {
+                    gasRefund: message.gasRefund,
+                    executionGasUsed: message.gasLimit - gasLimit,
+                    exceptionError: errorMessage, // Only defined if addToBalance failed
+                    returnValue: new Uint8Array(0),
+                    logs: eip7708Log ? [eip7708Log] : undefined,
+                },
+            };
+        }
+        let result;
+        if (message.isCompiled) {
+            let timer;
+            let callTimer;
+            let target;
+            if (this._optsCached.profiler?.enabled === true) {
+                // Using deprecated bytesToUnprefixedHex for performance: used for profiler string formatting.
+                target = bytesToUnprefixedHex(message.codeAddress.bytes);
+                // TODO: map target precompile not to address, but to a name
+                target = getPrecompileName(target) ?? target.slice(20);
+                if (this.performanceLogger.hasTimer()) {
+                    callTimer = this.performanceLogger.pauseTimer();
+                }
+                timer = this.performanceLogger.startTimer(target);
+            }
+            result = await this.runPrecompile(message.code, message.data, gasLimit);
+            if (eip7708Log !== undefined) {
+                result.logs = result.logs !== undefined ? [eip7708Log, ...result.logs] : [eip7708Log];
+            }
+            if (this._optsCached.profiler?.enabled === true) {
+                this.performanceLogger.stopTimer(timer, Number(result.executionGasUsed), 'precompiles');
+                if (callTimer !== undefined) {
+                    this.performanceLogger.unpauseTimer(callTimer);
+                }
+            }
+            result.gasRefund = message.gasRefund;
+        }
+        else {
+            if (this.DEBUG) {
+                debug(`Start bytecode processing...`);
+            }
+            result = await this.runInterpreter({
+                ...{ codeAddress: message.codeAddress },
+                ...message,
+                gasLimit,
+            }, { initialLogs: eip7708Log ? [eip7708Log] : undefined });
+        }
+        if (message.depth === 0) {
+            this.postMessageCleanup();
+        }
+        result.executionGasUsed += message.gasLimit - gasLimit;
+        return {
+            execResult: result,
+        };
+    }
+    async _executeCreate(message) {
+        let gasLimit = message.gasLimit;
+        const fromAddress = message.caller;
+        if (this.common.isActivatedEIP(6800) || this.common.isActivatedEIP(7864)) {
+            if (message.depth === 0) {
+                const originAccessGas = message.accessWitness.readAccountHeader(fromAddress);
+                debugGas(`originAccessGas=${originAccessGas} waived off for origin at depth=0`);
+            }
+        }
+        let account = await this.stateManager.getAccount(message.caller);
+        if (!account) {
+            account = new Account();
+        }
+        // Reduce tx value from sender
+        await this._reduceSenderBalance(account, message);
+        if (this.common.isActivatedEIP(3860)) {
+            if (message.data.length > Number(this.common.param('maxInitCodeSize')) &&
+                !this.allowUnlimitedInitCodeSize) {
+                return {
+                    createdAddress: message.to,
+                    execResult: {
+                        returnValue: new Uint8Array(0),
+                        exceptionError: new EVMError(EVMError.errorMessages.INITCODE_SIZE_VIOLATION),
+                        executionGasUsed: message.gasLimit,
+                    },
+                };
+            }
+        }
+        // TODO at some point, figure out why we swapped out data to code in the first place
+        message.code = message.data;
+        message.data = message.eofCallData ?? new Uint8Array();
+        message.to = await this._generateAddress(message);
+        if (this.common.isActivatedEIP(6780)) {
+            message.createdAddresses.add(message.to.toString());
+        }
+        if (this.DEBUG) {
+            debug(`Generated CREATE contract address ${message.to}`);
+        }
+        let toAccount = await this.stateManager.getAccount(message.to);
+        if (!toAccount) {
+            toAccount = new Account();
+        }
+        if (this.common.isActivatedEIP(6800) || this.common.isActivatedEIP(7864)) {
+            const contractCreateAccessGas = message.accessWitness.writeAccountBasicData(message.to) +
+                message.accessWitness.readAccountCodeHash(message.to);
+            gasLimit -= contractCreateAccessGas;
+            if (gasLimit < BIGINT_0) {
+                if (this.DEBUG) {
+                    debugGas(`ContractCreateInit charge(${contractCreateAccessGas}) caused OOG (-> ${gasLimit})`);
+                    message.accessWitness?.revert();
+                }
+                return { execResult: OOGResult(message.gasLimit) };
+            }
+            else {
+                if (this.DEBUG) {
+                    debugGas(`ContractCreateInit charged (${contractCreateAccessGas} gas (-> ${gasLimit}))`);
+                }
+                message.accessWitness?.commit();
+            }
+        }
+        // Check for collision
+        if ((toAccount.nonce && toAccount.nonce > BIGINT_0) ||
+            !(equalsBytes(toAccount.codeHash, KECCAK256_NULL) === true) ||
+            // See EIP 7610 and the discussion `https://ethereum-magicians.org/t/eip-7610-revert-creation-in-case-of-non-empty-storage`
+            !(equalsBytes(toAccount.storageRoot, KECCAK256_RLP) === true)) {
+            if (this.DEBUG) {
+                debug(`Returning on address collision`);
+            }
+            if (this.common.isActivatedEIP(7928)) {
+                this.blockLevelAccessList.addAddress(message.to.toString());
+            }
+            return {
+                createdAddress: message.to,
+                execResult: {
+                    returnValue: new Uint8Array(0),
+                    exceptionError: new EVMError(EVMError.errorMessages.CREATE_COLLISION),
+                    executionGasUsed: message.gasLimit,
+                },
+            };
+        }
+        await this.journal.putAccount(message.to, toAccount);
+        await this.stateManager.clearStorage(message.to);
+        const newContractEvent = {
+            address: message.to,
+            code: message.code,
+        };
+        await this._emit('newContract', newContractEvent);
+        toAccount = await this.stateManager.getAccount(message.to);
+        if (!toAccount) {
+            toAccount = new Account();
+        }
+        // EIP-161 on account creation and CREATE execution
+        if (this.common.gteHardfork(Hardfork.SpuriousDragon)) {
+            toAccount.nonce += BIGINT_1;
+        }
+        if (this.common.isActivatedEIP(7928)) {
+            this.blockLevelAccessList.addNonceChange(message.to.toString(), toAccount.nonce, this.blockLevelAccessList.blockAccessIndex);
+        }
+        // Add tx value to the `to` account
+        let errorMessage;
+        try {
+            await this._addToBalance(toAccount, message);
+        }
+        catch (e) {
+            errorMessage = e;
+        }
+        let exit = false;
+        if (message.code === undefined ||
+            (typeof message.code !== 'function' && message.code.length === 0)) {
+            exit = true;
+            if (this.DEBUG) {
+                debug(`Exit early on no code (CREATE)`);
+            }
+        }
+        if (errorMessage !== undefined) {
+            exit = true;
+            if (this.DEBUG) {
+                debug(`Exit early on value transfer overflowed (CREATE)`);
+            }
+        }
+        // EIP-7708: Create ETH transfer log for contract creation with value
+        let eip7708CreateLog;
+        if (this.common.isActivatedEIP(7708) &&
+            message.value > BIGINT_0 &&
+            message.to !== undefined &&
+            !equalsBytes(message.caller.bytes, message.to.bytes) &&
+            errorMessage === undefined) {
+            eip7708CreateLog = createEIP7708TransferLog(message.caller, message.to, message.value);
+            if (this.DEBUG) {
+                debug(`EIP-7708: Created ETH transfer log for CREATE from ${message.caller} to ${message.to} value=${message.value}`);
+            }
+        }
+        if (exit) {
+            if (this.common.isActivatedEIP(6800) || this.common.isActivatedEIP(7864)) {
+                const createCompleteAccessGas = message.accessWitness.writeAccountHeader(message.to);
+                gasLimit -= createCompleteAccessGas;
+                if (gasLimit < BIGINT_0) {
+                    if (this.DEBUG) {
+                        debug(`ContractCreateComplete access gas (${createCompleteAccessGas}) caused OOG (-> ${gasLimit})`);
+                    }
+                    message.accessWitness?.revert();
+                    return { execResult: OOGResult(message.gasLimit) };
+                }
+                else {
+                    if (this.DEBUG) {
+                        debug(`ContractCreateComplete access used (${createCompleteAccessGas}) gas (-> ${gasLimit})`);
+                    }
+                    message.accessWitness?.commit();
+                }
+            }
+            return {
+                createdAddress: message.to,
+                execResult: {
+                    executionGasUsed: message.gasLimit - gasLimit,
+                    gasRefund: message.gasRefund,
+                    exceptionError: errorMessage, // only defined if addToBalance failed
+                    returnValue: new Uint8Array(0),
+                    logs: eip7708CreateLog ? [eip7708CreateLog] : undefined,
+                },
+            };
+        }
+        if (this.DEBUG) {
+            debug(`Start bytecode processing...`);
+        }
+        // run the message with the updated gas limit and add accessed gas used to the result
+        let result = await this.runInterpreter({ ...message, gasLimit, isCreate: true }, {
+            initialLogs: eip7708CreateLog ? [eip7708CreateLog] : undefined,
+        });
+        result.executionGasUsed += message.gasLimit - gasLimit;
+        // fee for size of the return value
+        let totalGas = result.executionGasUsed;
+        let returnFee = BIGINT_0;
+        if (!result.exceptionError && !this.common.isActivatedEIP(6800)) {
+            returnFee = BigInt(result.returnValue.length) * BigInt(this.common.param('createDataGas'));
+            totalGas = totalGas + returnFee;
+            if (this.DEBUG) {
+                debugGas(`Add return value size fee (${returnFee} to gas used (-> ${totalGas}))`);
+            }
+        }
+        // Check for SpuriousDragon EIP-170 code size limit
+        let allowedCodeSize = true;
+        if (!result.exceptionError &&
+            this.common.gteHardfork(Hardfork.SpuriousDragon) &&
+            result.returnValue.length > Number(this.common.param('maxCodeSize'))) {
+            allowedCodeSize = false;
+        }
+        // If enough gas and allowed code size
+        let CodestoreOOG = false;
+        if (totalGas <= message.gasLimit && (this.allowUnlimitedContractSize || allowedCodeSize)) {
+            if (this.common.isActivatedEIP(3541) && result.returnValue[0] === FORMAT) {
+                if (!this.common.isActivatedEIP(3540)) {
+                    result = { ...result, ...INVALID_BYTECODE_RESULT(message.gasLimit) };
+                }
+                else if (
+                // TODO check if this is correct
+                // Also likely cleanup this eofCallData stuff
+                /*(message.depth > 0 && message.eofCallData === undefined) ||
+                (message.depth === 0 && !isEOF(message.code))*/
+                !isEOF(message.code)) {
+                    // TODO the message.eof was flagged for this to work for this first
+                    // Running into Legacy mode: unable to deploy EOF contract
+                    result = { ...result, ...INVALID_BYTECODE_RESULT(message.gasLimit) };
+                }
+                else {
+                    // 3541 is active and current runtime mode is EOF
+                    result.executionGasUsed = totalGas;
+                }
+            }
+            else {
+                result.executionGasUsed = totalGas;
+            }
+        }
+        else {
+            if (this.common.gteHardfork(Hardfork.Homestead)) {
+                if (!allowedCodeSize) {
+                    if (this.DEBUG) {
+                        debug(`Code size exceeds maximum code size (>= SpuriousDragon)`);
+                    }
+                    result = { ...result, ...CodesizeExceedsMaximumError(message.gasLimit) };
+                }
+                else {
+                    if (this.DEBUG) {
+                        debug(`Contract creation: out of gas`);
+                    }
+                    message.accessWitness?.revert();
+                    result = { ...result, ...OOGResult(message.gasLimit) };
+                }
+            }
+            else {
+                // we are in Frontier
+                if (totalGas - returnFee <= message.gasLimit) {
+                    // we cannot pay the code deposit fee (but the deposit code actually did run)
+                    if (this.DEBUG) {
+                        debug(`Not enough gas to pay the code deposit fee (Frontier)`);
+                    }
+                    message.accessWitness?.revert();
+                    result = { ...result, ...COOGResult(totalGas - returnFee) };
+                    CodestoreOOG = true;
+                }
+                else {
+                    if (this.DEBUG) {
+                        debug(`Contract creation: out of gas`);
+                    }
+                    message.accessWitness?.revert();
+                    result = { ...result, ...OOGResult(message.gasLimit) };
+                }
+            }
+        }
+        // get the fresh gas limit for the rest of the ops
+        gasLimit = message.gasLimit - result.executionGasUsed;
+        if (!result.exceptionError &&
+            (this.common.isActivatedEIP(6800) || this.common.isActivatedEIP(7864))) {
+            const createCompleteAccessGas = message.accessWitness.writeAccountHeader(message.to);
+            gasLimit -= createCompleteAccessGas;
+            if (gasLimit < BIGINT_0) {
+                if (this.DEBUG) {
+                    debug(`ContractCreateComplete access gas (${createCompleteAccessGas}) caused OOG (-> ${gasLimit})`);
+                }
+                message.accessWitness?.revert();
+                result = { ...result, ...OOGResult(message.gasLimit) };
+            }
+            else {
+                debug(`ContractCreateComplete access used (${createCompleteAccessGas}) gas (-> ${gasLimit})`);
+                result.executionGasUsed += createCompleteAccessGas;
+            }
+        }
+        // Save code if a new contract was created
+        if (!result.exceptionError &&
+            result.returnValue !== undefined &&
+            result.returnValue.length !== 0) {
+            // Add access charges for writing this code to the state
+            if (this.common.isActivatedEIP(6800) || this.common.isActivatedEIP(7864)) {
+                const byteCodeWriteAccessfee = message.accessWitness.writeAccountCodeChunks(message.to, 0, result.returnValue.length - 1);
+                gasLimit -= byteCodeWriteAccessfee;
+                if (gasLimit < BIGINT_0) {
+                    if (this.DEBUG) {
+                        debug(`byteCodeWrite access gas (${byteCodeWriteAccessfee}) caused OOG (-> ${gasLimit})`);
+                    }
+                    message.accessWitness?.revert();
+                    result = { ...result, ...OOGResult(message.gasLimit) };
+                }
+                else {
+                    debug(`byteCodeWrite access used (${byteCodeWriteAccessfee}) gas (-> ${gasLimit})`);
+                    message.accessWitness?.commit();
+                    result.executionGasUsed += byteCodeWriteAccessfee;
+                }
+            }
+            await this.stateManager.putCode(message.to, result.returnValue);
+            if (this.common.isActivatedEIP(7928)) {
+                this.blockLevelAccessList.addCodeChange(message.to.toString(), result.returnValue, this.blockLevelAccessList.blockAccessIndex);
+            }
+            if (this.DEBUG) {
+                debug(`Code saved on new contract creation`);
+            }
+        }
+        else if (CodestoreOOG) {
+            // This only happens at Frontier. But, let's do a sanity check;
+            if (!this.common.gteHardfork(Hardfork.Homestead)) {
+                // Pre-Homestead behavior; put an empty contract.
+                // This contract would be considered "DEAD" in later hard forks.
+                // It is thus an unnecessary default item, which we have to save to disk
+                // It does change the state root, but it only wastes storage.
+                const account = await this.stateManager.getAccount(message.to);
+                await this.journal.putAccount(message.to, account ?? new Account());
+            }
+        }
+        if (message.depth === 0) {
+            this.postMessageCleanup();
+        }
+        return {
+            createdAddress: message.to,
+            execResult: result,
+        };
+    }
+    /**
+     * Starts the actual bytecode processing for a CALL or CREATE
+     */
+    async runInterpreter(message, opts = {}) {
+        let contract = await this.stateManager.getAccount(message.to ?? createZeroAddress());
+        if (!contract) {
+            contract = new Account();
+        }
+        const env = {
+            address: message.to ?? createZeroAddress(),
+            caller: message.caller ?? createZeroAddress(),
+            callData: message.data ?? Uint8Array.from([0]),
+            callValue: message.value ?? BIGINT_0,
+            code: message.code,
+            isStatic: message.isStatic ?? false,
+            isCreate: message.isCreate ?? false,
+            depth: message.depth ?? 0,
+            gasPrice: this._tx.gasPrice,
+            origin: this._tx.origin ?? message.caller ?? createZeroAddress(),
+            block: this._block ?? defaultBlock(),
+            contract,
+            codeAddress: message.codeAddress,
+            gasRefund: message.gasRefund,
+            chargeCodeAccesses: message.chargeCodeAccesses,
+            blobVersionedHashes: message.blobVersionedHashes ?? [],
+            accessWitness: message.accessWitness,
+            createdAddresses: message.createdAddresses,
+            initialLogs: opts.initialLogs,
+        };
+        const interpreter = new Interpreter(this, this.stateManager, this.blockchain, env, message.gasLimit, this.journal, this.performanceLogger, this._optsCached.profiler);
+        if (message.selfdestruct) {
+            interpreter._result.selfdestruct = message.selfdestruct;
+        }
+        if (message.createdAddresses) {
+            interpreter._result.createdAddresses = message.createdAddresses;
+        }
+        const interpreterRes = await interpreter.run(message.code, opts);
+        let result = interpreter._result;
+        let gasUsed = message.gasLimit - interpreterRes.runState.gasLeft;
+        if (interpreterRes.exceptionError) {
+            if (interpreterRes.exceptionError.error !== EVMError.errorMessages.REVERT &&
+                interpreterRes.exceptionError.error !== EVMError.errorMessages.INVALID_EOF_FORMAT) {
+                gasUsed = message.gasLimit;
+            }
+            // Clear the result on error
+            result = {
+                ...result,
+                logs: [],
+                selfdestruct: new Map(),
+                createdAddresses: new Set(),
+            };
+        }
+        message.accessWitness?.commit();
+        return {
+            ...result,
+            runState: {
+                ...interpreterRes.runState,
+                ...result,
+                ...interpreter._env,
+            },
+            exceptionError: interpreterRes.exceptionError,
+            gas: interpreterRes.runState?.gasLeft,
+            executionGasUsed: gasUsed,
+            gasRefund: interpreterRes.runState.gasRefund,
+            returnValue: result.returnValue ?? new Uint8Array(0),
+        };
+    }
+    /**
+     * Executes an EVM message, determining whether it's a call or create
+     * based on the `to` address. It checkpoints the state and reverts changes
+     * if an exception happens during the message execution.
+     */
+    async runCall(opts) {
+        let timer;
+        if ((opts.depth === 0 || opts.message === undefined) &&
+            this._optsCached.profiler?.enabled === true) {
+            timer = this.performanceLogger.startTimer('Initialization');
+        }
+        let message = opts.message;
+        let callerAccount;
+        if (!message) {
+            this._block = opts.block ?? defaultBlock();
+            const caller = opts.caller ?? createZeroAddress();
+            this._tx = {
+                gasPrice: opts.gasPrice ?? BIGINT_0,
+                origin: opts.origin ?? caller,
+            };
+            const value = opts.value ?? BIGINT_0;
+            if (opts.skipBalance === true) {
+                callerAccount = await this.stateManager.getAccount(caller);
+                if (!callerAccount) {
+                    callerAccount = new Account();
+                }
+                const originalBalance = callerAccount.balance;
+                if (callerAccount.balance < value) {
+                    // if skipBalance and balance less than value, set caller balance to `value` to ensure sufficient funds
+                    callerAccount.balance = value;
+                    await this.journal.putAccount(caller, callerAccount);
+                    if (this.common.isActivatedEIP(7928)) {
+                        this.blockLevelAccessList.addBalanceChange(caller.toString(), callerAccount.balance, this.blockLevelAccessList.blockAccessIndex, originalBalance);
+                    }
+                }
+            }
+            message = new Message({
+                caller,
+                gasLimit: opts.gasLimit ?? BigInt(0xffffff),
+                to: opts.to,
+                value,
+                data: opts.data,
+                code: opts.code,
+                depth: opts.depth,
+                isCompiled: opts.isCompiled,
+                isStatic: opts.isStatic,
+                salt: opts.salt,
+                selfdestruct: opts.selfdestruct ?? new Map(),
+                createdAddresses: opts.createdAddresses ?? new Set(),
+                delegatecall: opts.delegatecall,
+                blobVersionedHashes: opts.blobVersionedHashes,
+            });
+        }
+        if (message.depth === 0) {
+            if (!callerAccount) {
+                callerAccount = await this.stateManager.getAccount(message.caller);
+            }
+            if (!callerAccount) {
+                callerAccount = new Account();
+            }
+            callerAccount.nonce++;
+            await this.journal.putAccount(message.caller, callerAccount);
+            if (this.common.isActivatedEIP(7928)) {
+                this.blockLevelAccessList.addNonceChange(message.caller.toString(), callerAccount.nonce, this.blockLevelAccessList.blockAccessIndex);
+            }
+            if (this.DEBUG) {
+                debug(`Update fromAccount (caller) nonce (-> ${callerAccount.nonce}))`);
+            }
+        }
+        await this._emit('beforeMessage', message);
+        if (!message.to && this.common.isActivatedEIP(2929)) {
+            message.code = message.data;
+            this.journal.addWarmedAddress((await this._generateAddress(message)).bytes);
+        }
+        if (this.common.isActivatedEIP(7928)) {
+            this.blockLevelAccessList?.checkpoint();
+        }
+        await this.journal.checkpoint();
+        if (this.common.isActivatedEIP(1153))
+            this.transientStorage.checkpoint();
+        if (this.DEBUG) {
+            debug('-'.repeat(100));
+            debug(`message checkpoint`);
+        }
+        let result;
+        if (this.DEBUG) {
+            const { caller, gasLimit, to, value, delegatecall } = message;
+            debug(`New message caller=${caller} gasLimit=${gasLimit} to=${to?.toString() ?? 'none'} value=${value} delegatecall=${delegatecall ? 'yes' : 'no'}`);
+        }
+        if (message.to) {
+            if (this.DEBUG) {
+                debug(`Message CALL execution (to: ${message.to})`);
+            }
+            result = await this._executeCall(message);
+        }
+        else {
+            if (this.DEBUG) {
+                debug(`Message CREATE execution (to: undefined)`);
+            }
+            result = await this._executeCreate(message);
+        }
+        if (this.DEBUG) {
+            const { executionGasUsed, exceptionError, returnValue } = result.execResult;
+            debug(`Received message execResult: [ gasUsed=${executionGasUsed} exceptionError=${exceptionError ? `'${exceptionError.error}'` : 'none'} returnValue=${short(returnValue)} gasRefund=${result.execResult.gasRefund ?? 0} ]`);
+        }
+        const err = result.execResult.exceptionError;
+        // This clause captures any error which happened during execution
+        // If that is the case, then all refunds are forfeited
+        // There is one exception: if the CODESTORE_OUT_OF_GAS error is thrown
+        // (this only happens the Frontier/Chainstart fork)
+        // then the error is dismissed
+        if (err && err.error !== EVMError.errorMessages.CODESTORE_OUT_OF_GAS) {
+            result.execResult.selfdestruct = new Map();
+            result.execResult.createdAddresses = new Set();
+            result.execResult.gasRefund = BIGINT_0;
+        }
+        if (err &&
+            !(this.common.hardfork() === Hardfork.Chainstart &&
+                err.error === EVMError.errorMessages.CODESTORE_OUT_OF_GAS)) {
+            result.execResult.logs = [];
+            await this.journal.revert();
+            if (this.common.isActivatedEIP(1153))
+                this.transientStorage.revert();
+            if (this.common.isActivatedEIP(7928)) {
+                this.blockLevelAccessList?.revert();
+            }
+            if (this.DEBUG) {
+                debug(`message checkpoint reverted`);
+            }
+        }
+        else {
+            await this.journal.commit();
+            if (this.common.isActivatedEIP(1153))
+                this.transientStorage.commit();
+            if (this.common.isActivatedEIP(7928)) {
+                this.blockLevelAccessList?.commit();
+            }
+            if (this.DEBUG) {
+                debug(`message checkpoint committed`);
+            }
+        }
+        await this._emit('afterMessage', result);
+        if (message.depth === 0 && this._optsCached.profiler?.enabled === true) {
+            this.performanceLogger.stopTimer(timer, 0);
+        }
+        message.accessWitness?.commit();
+        return result;
+    }
+    /**
+     * Bound to the global VM and therefore
+     * shouldn't be used directly from the evm class
+     */
+    async runCode(opts) {
+        this._block = opts.block ?? defaultBlock();
+        this._tx = {
+            gasPrice: opts.gasPrice ?? BIGINT_0,
+            origin: opts.origin ?? opts.caller ?? createZeroAddress(),
+        };
+        const message = new Message({
+            code: opts.code,
+            data: opts.data,
+            gasLimit: opts.gasLimit ?? BigInt(0xffffff),
+            to: opts.to ?? createZeroAddress(),
+            caller: opts.caller,
+            value: opts.value,
+            depth: opts.depth,
+            selfdestruct: opts.selfdestruct ?? new Map(),
+            isStatic: opts.isStatic,
+            blobVersionedHashes: opts.blobVersionedHashes,
+        });
+        return this.runInterpreter(message, { pc: opts.pc });
+    }
+    /**
+     * Returns the precompile function registered at the given address,
+     * or `undefined` if no precompile is active there.
+     *
+     * Accepts either an `Address` instance or a `0x`-prefixed hex string.
+     *
+     * ```ts
+     * const evm = await createEVM({
+     *   customPrecompiles: [{ address: '0x000000000000000000000000000000000000ff01', function: myFn }],
+     * })
+     * const fn = evm.getPrecompile('0x000000000000000000000000000000000000ff01')
+     * ```
+     */
+    getPrecompile(address) {
+        if (typeof address === 'string') {
+            return this.precompiles.get(address.slice(2).padStart(40, '0').toLowerCase());
+        }
+        return this.precompiles.get(bytesToUnprefixedHex(address.bytes));
+    }
+    /**
+     * Executes a precompiled contract with given data and gas limit.
+     */
+    runPrecompile(code, data, gasLimit) {
+        if (typeof code !== 'function') {
+            throw EthereumJSErrorWithoutCode('Invalid precompile');
+        }
+        const opts = {
+            data,
+            gasLimit,
+            common: this.common,
+            _EVM: this,
+            _debug: this.DEBUG ? debugPrecompiles : undefined,
+            stateManager: this.stateManager,
+        };
+        return code(opts);
+    }
+    async _loadCode(message) {
+        if (!message.code) {
+            const precompile = this.getPrecompile(message.codeAddress);
+            if (precompile) {
+                message.code = precompile;
+                message.isCompiled = true;
+            }
+            else {
+                message.code = await this.stateManager.getCode(message.codeAddress);
+                // EIP-7702 delegation check
+                if (this.common.isActivatedEIP(7702) &&
+                    equalsBytes(message.code.slice(0, 3), DELEGATION_7702_FLAG)) {
+                    const address = new Address(message.code.slice(3, 24));
+                    message.code = await this.stateManager.getCode(address);
+                    // EIP-7928: Track delegation target access in BAL
+                    if (this.common.isActivatedEIP(7928)) {
+                        this.blockLevelAccessList?.addAddress(address.toString());
+                    }
+                    if (message.depth === 0) {
+                        this.journal.addAlwaysWarmAddress(address.toString());
+                    }
+                }
+                message.isCompiled = false;
+                message.chargeCodeAccesses = true;
+            }
+        }
+    }
+    async _generateAddress(message) {
+        let addr;
+        if (message.salt) {
+            addr = generateAddress2(message.caller.bytes, message.salt, message.code);
+        }
+        else {
+            let acc = await this.stateManager.getAccount(message.caller);
+            if (!acc) {
+                acc = new Account();
+            }
+            const newNonce = acc.nonce - BIGINT_1;
+            addr = generateAddress(message.caller.bytes, bigIntToBytes(newNonce));
+        }
+        return new Address(addr);
+    }
+    async _reduceSenderBalance(account, message) {
+        const originalBalance = account.balance;
+        account.balance -= message.value;
+        if (account.balance < BIGINT_0) {
+            throw new EVMError(EVMError.errorMessages.INSUFFICIENT_BALANCE);
+        }
+        // EIP-7928: Record the sender's reduced balance in BAL
+        // Per spec, CALL/CALLCODE senders must have their balance recorded
+        if (this.common.isActivatedEIP(7928)) {
+            this.blockLevelAccessList.addBalanceChange(message.caller.toString(), account.balance, this.blockLevelAccessList.blockAccessIndex, originalBalance);
+        }
+        const result = this.journal.putAccount(message.caller, account);
+        if (this.DEBUG) {
+            debug(`Reduced sender (${message.caller}) balance (-> ${account.balance})`);
+        }
+        return result;
+    }
+    async _addToBalance(toAccount, message) {
+        const originalBalance = toAccount.balance;
+        const newBalance = toAccount.balance + message.value;
+        if (newBalance > MAX_INTEGER) {
+            throw new EVMError(EVMError.errorMessages.VALUE_OVERFLOW);
+        }
+        toAccount.balance = newBalance;
+        if (this.common.isActivatedEIP(7928)) {
+            this.blockLevelAccessList.addAddress(message.to.toString());
+            if (message.value !== BIGINT_0) {
+                this.blockLevelAccessList.addBalanceChange(message.to.toString(), newBalance, this.blockLevelAccessList.blockAccessIndex, originalBalance);
+            }
+        }
+        // putAccount as the nonce may have changed for contract creation
+        await this.journal.putAccount(message.to, toAccount);
+        if (this.DEBUG) {
+            debug(`Added toAccount (${message.to}) balance (-> ${toAccount.balance})`);
+        }
+    }
+    /**
+     * Once the interpreter has finished depth 0, a post-message cleanup should be done
+     */
+    postMessageCleanup() {
+        if (this.common.isActivatedEIP(1153))
+            this.transientStorage.clear();
+    }
+    /**
+     * This method copies the EVM, current HF and EIP settings
+     * and returns a new EVM instance.
+     *
+     * Note: this is only a shallow copy and both EVM instances
+     * will point to the same underlying state DB.
+     *
+     * @returns EVM
+     */
+    shallowCopy() {
+        const common = this.common.copy();
+        common.setHardfork(this.common.hardfork());
+        const opts = {
+            ...this._optsCached,
+            common,
+            stateManager: this.stateManager.shallowCopy(),
+        };
+        // @ts-expect-error -- Assigning a StateManager property that is absent from the interface
+        opts.stateManager['common'] = common;
+        return new EVM(opts);
+    }
+    getPerformanceLogs() {
+        return this.performanceLogger.getLogs();
+    }
+    clearPerformanceLogs() {
+        this.performanceLogger.clear();
+    }
+}
+EVM.supportedHardforks = [
+    Hardfork.Chainstart,
+    Hardfork.Homestead,
+    Hardfork.Dao,
+    Hardfork.TangerineWhistle,
+    Hardfork.SpuriousDragon,
+    Hardfork.Byzantium,
+    Hardfork.Constantinople,
+    Hardfork.Petersburg,
+    Hardfork.Istanbul,
+    Hardfork.MuirGlacier,
+    Hardfork.Berlin,
+    Hardfork.London,
+    Hardfork.ArrowGlacier,
+    Hardfork.GrayGlacier,
+    Hardfork.MergeNetsplitBlock,
+    Hardfork.Paris,
+    Hardfork.Shanghai,
+    Hardfork.Cancun,
+    Hardfork.Prague,
+    Hardfork.Osaka,
+    Hardfork.Bpo1,
+    Hardfork.Bpo2,
+    Hardfork.Bpo3,
+    Hardfork.Bpo4,
+    Hardfork.Bpo5,
+    Hardfork.Amsterdam,
+];
+//# sourceMappingURL=evm.js.map