vm

package
v1.17.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 22, 2026 License: GPL-3.0, LGPL-3.0 Imports: 34 Imported by: 5,644

Documentation

Overview

Package vm implements the Ethereum Virtual Machine.

The vm package implements one EVM, a byte code VM. The BC (Byte Code) VM loops over a set of bytes and executes them according to the set of rules defined in the Ethereum yellow paper.

Example (MainnetEIP7610Accounts) 
list := slices.Clone(eip7610Accounts[params.MainnetChainConfig.ChainID.Uint64()])
slices.SortFunc(list, common.Address.Cmp)
for _, addr := range list {
	fmt.Println(addr.Hex())
}

Output:
0x02820E4bEE488C40f7455fDCa53125565148708F
0x14725085d004f1b10Ee07234A4ab28c5Ad2a7b9E
0x19272418753B90D9a3E3Efc8430b1612c55fcB3A
0x2c081Ed1949D7Dd9447F9d96e509befE576D4461
0x3311c08066580cb906a7287b6786E504C2EBD09f
0x361d7a60b43587c7f6bbA4f9fD9642747F65210A
0x40490C9c468622d5c89646D6F3097F8Eaf80c411
0x4d149EB99BDEEFC1f858f8fd22289C6beAE99f2c
0x5071cb62aA170b7f66b26cae8004d90E6078Bb1E
0x50b1497068bAE652Df3562EB8Ea7677ff84477FA
0x5983C6aC846DcF85fbBC4303F43eb91C379F79ae
0x59EC0410867828E3b8c23Dd8A29d9796ef523b17
0x5cC182faBFb81A056B6080d4200BC5150673D06f
0x6f156dbf8Ed30e53F7C9Df73144E69f65cBB7E94
0x7D6ae067De8d44Ae1A08750e7D626D61A623C44A
0x8398fF6c618e9515468c1c4b198d53666CBe8462
0xA21B22389bfC1cd6Bc7BA19A4Fc96aDC3D0FE074
0xaDD92e0650457C5Db0c4c08cbf7cA580175d33d2
0xAE3703584494Ade958AD27EC2d289b7a67c19E90
0xb619f45637C39Ca49A41ac64c11637A0A194455E
0xD8253352f6044cFE55bcC0748C3FA37b7dF81F98
0xDB7C577B93Baeb56dAB50aF4D6f86F99A06B96a2
0xdE425ad4B8d2d9E0E12F65CBcD6D55F447B44083
0xe62dc49C92fA799033644d2A9aFD7e3BAbE5A80a
0xF468BcBC4a0BFDB06336E773382C5202E674db71
0xF4a835ec1364809003dE3925685F24cD360bdffe
0xFc4465F84B29a1F8794Dc753F41BeF1F4b025ED2
0xfeE7707fa4b8C0A923A0E40399Db3e7Ce26069C6

Index

Examples

Constants

View Source 
const (
	VMErrorCodeOutOfGas = 1 + iota
	VMErrorCodeCodeStoreOutOfGas
	VMErrorCodeDepth
	VMErrorCodeInsufficientBalance
	VMErrorCodeContractAddressCollision
	VMErrorCodeExecutionReverted
	VMErrorCodeMaxCodeSizeExceeded
	VMErrorCodeInvalidJump
	VMErrorCodeWriteProtection
	VMErrorCodeReturnDataOutOfBounds
	VMErrorCodeGasUintOverflow
	VMErrorCodeInvalidCode
	VMErrorCodeNonceUintOverflow
	VMErrorCodeStackUnderflow
	VMErrorCodeStackOverflow
	VMErrorCodeInvalidOpCode

	// VMErrorCodeUnknown explicitly marks an error as unknown, this is useful when error is converted
	// from an actual `error` in which case if the mapping is not known, we can use this value to indicate that.
	VMErrorCodeUnknown = math.MaxInt - 1
)
View Source 
const (
	GasQuickStep   uint64 = 2
	GasFastestStep uint64 = 3
	GasFastishStep uint64 = 4
	GasFastStep    uint64 = 5
	GasMidStep     uint64 = 8
	GasSlowStep    uint64 = 10
	GasExtStep     uint64 = 20
)

Gas costs

Variables

View Source 
var (
	PrecompiledAddressesOsaka     []common.Address
	PrecompiledAddressesPrague    []common.Address
	PrecompiledAddressesCancun    []common.Address
	PrecompiledAddressesBerlin    []common.Address
	PrecompiledAddressesIstanbul  []common.Address
	PrecompiledAddressesByzantium []common.Address
	PrecompiledAddressesHomestead []common.Address
)
View Source 
var (
	ErrOutOfGas                 = errors.New("out of gas")
	ErrCodeStoreOutOfGas        = errors.New("contract creation code storage out of gas")
	ErrDepth                    = errors.New("max call depth exceeded")
	ErrInsufficientBalance      = errors.New("insufficient balance for transfer")
	ErrContractAddressCollision = errors.New("contract address collision")
	ErrExecutionReverted        = errors.New("execution reverted")
	ErrMaxCodeSizeExceeded      = errors.New("max code size exceeded")
	ErrMaxInitCodeSizeExceeded  = errors.New("max initcode size exceeded")
	ErrInvalidJump              = errors.New("invalid jump destination")
	ErrWriteProtection          = errors.New("write protection")
	ErrReturnDataOutOfBounds    = errors.New("return data out of bounds")
	ErrGasUintOverflow          = errors.New("gas uint64 overflow")
	ErrInvalidCode              = errors.New("invalid code: must not begin with 0xef")
	ErrNonceUintOverflow        = errors.New("nonce uint64 overflow")
)

List evm execution errors

View Source 
var PrecompiledContractsBLS = PrecompiledContractsPrague
View Source 
var PrecompiledContractsBerlin = PrecompiledContracts{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: true, eip7823: false, eip7883: false},
	common.BytesToAddress([]byte{0x6}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x9}): &blake2F{},
}

PrecompiledContractsBerlin contains the default set of pre-compiled Ethereum contracts used in the Berlin release.

View Source 
var PrecompiledContractsByzantium = PrecompiledContracts{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: false, eip7823: false, eip7883: false},
	common.BytesToAddress([]byte{0x6}): &bn256AddByzantium{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulByzantium{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingByzantium{},
}

PrecompiledContractsByzantium contains the default set of pre-compiled Ethereum contracts used in the Byzantium release.

View Source 
var PrecompiledContractsCancun = PrecompiledContracts{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: true, eip7823: false, eip7883: false},
	common.BytesToAddress([]byte{0x6}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x9}): &blake2F{},
	common.BytesToAddress([]byte{0xa}): &kzgPointEvaluation{},
}

PrecompiledContractsCancun contains the default set of pre-compiled Ethereum contracts used in the Cancun release.

View Source 
var PrecompiledContractsHomestead = PrecompiledContracts{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
}

PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum contracts used in the Frontier and Homestead releases.

View Source 
var PrecompiledContractsIstanbul = PrecompiledContracts{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: false, eip7823: false, eip7883: false},
	common.BytesToAddress([]byte{0x6}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x9}): &blake2F{},
}

PrecompiledContractsIstanbul contains the default set of pre-compiled Ethereum contracts used in the Istanbul release.

View Source 
var PrecompiledContractsOsaka = PrecompiledContracts{
	common.BytesToAddress([]byte{0x01}): &ecrecover{},
	common.BytesToAddress([]byte{0x02}): &sha256hash{},
	common.BytesToAddress([]byte{0x03}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x04}): &dataCopy{},
	common.BytesToAddress([]byte{0x05}): &bigModExp{eip2565: true, eip7823: true, eip7883: true},
	common.BytesToAddress([]byte{0x06}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x07}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x08}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x09}): &blake2F{},
	common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{},
	common.BytesToAddress([]byte{0x0b}): &bls12381G1Add{},
	common.BytesToAddress([]byte{0x0c}): &bls12381G1MultiExp{},
	common.BytesToAddress([]byte{0x0d}): &bls12381G2Add{},
	common.BytesToAddress([]byte{0x0e}): &bls12381G2MultiExp{},
	common.BytesToAddress([]byte{0x0f}): &bls12381Pairing{},
	common.BytesToAddress([]byte{0x10}): &bls12381MapG1{},
	common.BytesToAddress([]byte{0x11}): &bls12381MapG2{},

	common.BytesToAddress([]byte{0x1, 0x00}): &p256Verify{},
}

PrecompiledContractsOsaka contains the set of pre-compiled Ethereum contracts used in the Osaka release.

View Source 
var PrecompiledContractsP256Verify = PrecompiledContracts{
	common.BytesToAddress([]byte{0x1, 0x00}): &p256Verify{},
}

PrecompiledContractsP256Verify contains the precompiled Ethereum contract specified in EIP-7212. This is exported for testing purposes.

View Source 
var PrecompiledContractsPrague = PrecompiledContracts{
	common.BytesToAddress([]byte{0x01}): &ecrecover{},
	common.BytesToAddress([]byte{0x02}): &sha256hash{},
	common.BytesToAddress([]byte{0x03}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x04}): &dataCopy{},
	common.BytesToAddress([]byte{0x05}): &bigModExp{eip2565: true, eip7823: false, eip7883: false},
	common.BytesToAddress([]byte{0x06}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x07}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x08}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x09}): &blake2F{},
	common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{},
	common.BytesToAddress([]byte{0x0b}): &bls12381G1Add{},
	common.BytesToAddress([]byte{0x0c}): &bls12381G1MultiExp{},
	common.BytesToAddress([]byte{0x0d}): &bls12381G2Add{},
	common.BytesToAddress([]byte{0x0e}): &bls12381G2MultiExp{},
	common.BytesToAddress([]byte{0x0f}): &bls12381Pairing{},
	common.BytesToAddress([]byte{0x10}): &bls12381MapG1{},
	common.BytesToAddress([]byte{0x11}): &bls12381MapG2{},
}

PrecompiledContractsPrague contains the set of pre-compiled Ethereum contracts used in the Prague release.

View Source 
var PrecompiledContractsVerkle = PrecompiledContractsBerlin

Functions

func ActivateableEips added in v1.9.16 

func ActivateableEips() []string

func ActivePrecompiles added in v1.10.2 

func ActivePrecompiles(rules params.Rules) []common.Address

ActivePrecompiles returns the precompile addresses enabled with the current configuration.

func CheckMaxCodeSize added in v1.17.2 

func CheckMaxCodeSize(rules *params.Rules, size uint64) error

CheckMaxCodeSize checks the size of contract code against the protocol-defined limit.

func CheckMaxInitCodeSize added in v1.17.2 

func CheckMaxInitCodeSize(rules *params.Rules, size uint64) error

CheckMaxInitCodeSize checks the size of contract initcode against the protocol-defined limit.

func EnableEIP added in v1.9.2 

func EnableEIP(eipNum int, jt *JumpTable) error

EnableEIP enables the given EIP on the config. This operation writes in-place, and callers need to ensure that the globally defined jump tables are not polluted.

func VMErrorFromErr added in v1.14.0 

func VMErrorFromErr(err error) error

func ValidEip added in v1.9.16 

func ValidEip(eipNum int) bool

Types

type BitVec added in v1.16.2 

type BitVec []byte

BitVec is a bit vector which maps bytes in a program. An unset bit means the byte is an opcode, a set bit means it's data (i.e. argument of PUSHxx).

type BlockContext added in v1.9.25 

type BlockContext struct {
	// CanTransfer returns whether the account contains
	// sufficient ether to transfer the value
	CanTransfer CanTransferFunc
	// Transfer transfers ether from one account to the other
	Transfer TransferFunc
	// GetHash returns the hash corresponding to n
	GetHash GetHashFunc

	// Block information
	Coinbase    common.Address // Provides information for COINBASE
	GasLimit    uint64         // Provides information for GASLIMIT
	BlockNumber *big.Int       // Provides information for NUMBER
	Time        uint64         // Provides information for TIME
	Difficulty  *big.Int       // Provides information for DIFFICULTY
	BaseFee     *big.Int       // Provides information for BASEFEE (0 if vm runs with NoBaseFee flag and 0 gas price)
	BlobBaseFee *big.Int       // Provides information for BLOBBASEFEE (0 if vm runs with NoBaseFee flag and 0 blob gas price)
	Random      *common.Hash   // Provides information for PREVRANDAO
	SlotNum     uint64         // Provides information for SLOTNUM

	CostPerStateByte uint64 // CostPerByte for new state after EIP-8037
}

BlockContext provides the EVM with auxiliary information. Once provided it shouldn't be modified.

type CanTransferFunc added in v1.5.5 

type CanTransferFunc func(StateDB, common.Address, *uint256.Int) bool

CanTransferFunc is the signature of a transfer guard function

type Config added in v1.4.0 

type Config struct {
	Tracer *tracing.Hooks

	NoBaseFee               bool  // Forces the EIP-1559 baseFee to 0 (needed for 0 price calls)
	EnablePreimageRecording bool  // Enables recording of SHA3/keccak preimages
	ExtraEips               []int // Additional EIPS that are to be enabled
}

Config are the configuration options for the Interpreter

type Contract added in v1.3.1 

type Contract struct {
	Code     []byte
	CodeHash common.Hash
	Input    []byte

	// is the execution frame represented by this object a contract deployment
	IsDeployment bool
	IsSystemCall bool

	// Gas carries the unified gas state for this frame: running balance,
	// reservoir, and per-frame usage accumulators. See GasBudget.
	Gas GasBudget
	// contains filtered or unexported fields
}

Contract represents an ethereum contract in the state database. It contains the contract code, calling arguments. Contract implements ContractRef

func NewContract added in v1.3.1 

func NewContract(caller common.Address, address common.Address, value *uint256.Int, gas GasBudget, jumpDests JumpDestCache) *Contract

NewContract returns a new contract environment for the execution of EVM.

func (*Contract) Address added in v1.3.1 

func (c *Contract) Address() common.Address

Address returns the contracts address

func (*Contract) Caller added in v1.3.4 

func (c *Contract) Caller() common.Address

Caller returns the caller of the contract.

Caller will recursively call caller when the contract is a delegate call, including that of caller's caller.

func (*Contract) GetOp added in v1.3.1 

func (c *Contract) GetOp(n uint64) OpCode

GetOp returns the n'th element in the contract's byte array

func (*Contract) SetCallCode added in v1.3.1 

func (c *Contract) SetCallCode(hash common.Hash, code []byte)

SetCallCode sets the code of the contract,

func (*Contract) Value added in v1.3.4 

func (c *Contract) Value() *uint256.Int

Value returns the contract's value (sent to it from it's caller)

type EVM added in v1.4.0 

type EVM struct {
	// Context provides auxiliary blockchain related information
	Context BlockContext
	TxContext

	// StateDB gives access to the underlying state
	StateDB StateDB

	// virtual machine configuration options used to initialise the evm
	Config Config
	// contains filtered or unexported fields
}

EVM is the Ethereum Virtual Machine base object and provides the necessary tools to run a contract on the given state with the provided context. It should be noted that any error generated through any of the calls should be considered a revert-state-and-consume-all-gas operation, no checks on specific errors should ever be performed. The interpreter makes sure that any errors generated are to be considered faulty code.

The EVM should never be reused and is not thread safe.

func NewEVM added in v1.5.6 

func NewEVM(blockCtx BlockContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM

NewEVM constructs an EVM instance with the supplied block context, state database and several configs. It meant to be used throughout the entire state transition of a block, with the transaction context switched as needed by calling evm.SetTxContext.

func (*EVM) Call added in v1.5.6 

func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, gas GasBudget, value *uint256.Int) (ret []byte, result GasBudget, err error)

Call executes the contract associated with the addr with the given input as parameters. It also handles any necessary value transfer required and takse the necessary steps to create accounts and reverses the state in case of an execution error or failed value transfer.

func (*EVM) CallCode added in v1.5.6 

func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byte, gas GasBudget, value *uint256.Int) (ret []byte, result GasBudget, err error)

CallCode executes the contract associated with the addr with the given input as parameters. It also handles any necessary value transfer required and takes the necessary steps to create accounts and reverses the state in case of an execution error or failed value transfer.

CallCode differs from Call in the sense that it executes the given address' code with the caller as context.

func (*EVM) Cancel added in v1.5.6 

func (evm *EVM) Cancel()

Cancel cancels any running EVM operation. This may be called concurrently and it's safe to be called multiple times.

func (*EVM) Cancelled added in v1.9.0 

func (evm *EVM) Cancelled() bool

Cancelled returns true if Cancel has been called

func (*EVM) ChainConfig added in v1.5.6 

func (evm *EVM) ChainConfig() *params.ChainConfig

ChainConfig returns the environment's chain configuration

func (*EVM) Create added in v1.5.6 

func (evm *EVM) Create(caller common.Address, code []byte, gas GasBudget, value *uint256.Int) (ret []byte, contractAddr common.Address, result GasBudget, err error)

Create creates a new contract using code as deployment code.

func (*EVM) Create2 added in v1.8.13 

func (evm *EVM) Create2(caller common.Address, code []byte, gas GasBudget, endowment *uint256.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, result GasBudget, err error)

Create2 creates a new contract using code as deployment code.

The different between Create2 with Create is Create2 uses keccak256(0xff ++ msg.sender ++ salt ++ keccak256(init_code))[12:] instead of the usual sender-and-nonce-hash as the address where the contract is initialized at.

func (*EVM) DelegateCall added in v1.5.6 

func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, addr common.Address, input []byte, gas GasBudget, value *uint256.Int) (ret []byte, result GasBudget, err error)

DelegateCall executes the contract associated with the addr with the given input as parameters. It reverses the state in case of an execution error.

DelegateCall differs from CallCode in the sense that it executes the given address' code with the caller as context and the caller is set to the caller of the caller.

func (*EVM) GetRules added in v1.17.4 

func (evm *EVM) GetRules() params.Rules

GetRules returns the chain rules used throughout the EVM execution.

func (*EVM) GetVMContext added in v1.14.0 

func (evm *EVM) GetVMContext() *tracing.VMContext

GetVMContext provides context about the block being executed as well as state to the tracers.

func (*EVM) Release added in v1.17.3 

func (evm *EVM) Release()

Release returns some memory allocated by the EVM, should be called after the EVM was used for the last time. Not necessary, but an improvement.

func (*EVM) Run added in v1.4.0 

func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error)

Run loops and evaluates the contract's code with the given input data and returns the return byte-slice and an error if one occurred.

It's important to note that any errors returned by the interpreter should be considered a revert-and-consume-all-gas operation except for ErrExecutionReverted which means revert-and-keep-gas-left.

func (*EVM) SetJumpDestCache added in v1.16.2 

func (evm *EVM) SetJumpDestCache(jumpDests JumpDestCache)

SetJumpDestCache configures the analysis cache.

func (*EVM) SetPrecompiles added in v1.14.9 

func (evm *EVM) SetPrecompiles(precompiles PrecompiledContracts)

SetPrecompiles sets the precompiled contracts for the EVM. This method is only used through RPC calls. It is not thread-safe.

func (*EVM) SetTxContext added in v1.15.0 

func (evm *EVM) SetTxContext(txCtx TxContext)

SetTxContext resets the EVM with a new transaction context. This is not threadsafe and should only be done very cautiously.

func (*EVM) StaticCall added in v1.7.0 

func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []byte, gas GasBudget) (ret []byte, result GasBudget, err error)

StaticCall executes the contract associated with the addr with the given input as parameters while disallowing any modifications to the state during the call. Opcodes that attempt to perform such modifications will result in exceptions instead of performing the modifications.

type ErrInvalidOpCode added in v1.9.14 

type ErrInvalidOpCode struct {
	// contains filtered or unexported fields
}

ErrInvalidOpCode wraps an evm error when an invalid opcode is encountered.

func (*ErrInvalidOpCode) Error added in v1.9.14 

func (e *ErrInvalidOpCode) Error() string

type ErrStackOverflow added in v1.9.14 

type ErrStackOverflow struct {
	// contains filtered or unexported fields
}

ErrStackOverflow wraps an evm error when the items on the stack exceeds the maximum allowance.

func (ErrStackOverflow) Error added in v1.9.14 

func (e ErrStackOverflow) Error() string

func (ErrStackOverflow) Unwrap added in v1.14.12 

func (e ErrStackOverflow) Unwrap() error

type ErrStackUnderflow added in v1.9.14 

type ErrStackUnderflow struct {
	// contains filtered or unexported fields
}

ErrStackUnderflow wraps an evm error when the items on the stack less than the minimal requirement.

func (ErrStackUnderflow) Error added in v1.9.14 

func (e ErrStackUnderflow) Error() string

func (ErrStackUnderflow) Unwrap added in v1.14.12 

func (e ErrStackUnderflow) Unwrap() error

type GasBudget added in v1.17.3 

type GasBudget struct {
	RegularGas     uint64 // remaining regular-gas balance (or leftover for caller to absorb)
	StateGas       uint64 // remaining state-gas reservoir (or leftover for caller to absorb)
	UsedRegularGas uint64 // gross regular gas consumed in this frame
	UsedStateGas   int64  // signed net state-gas consumed in this frame
}

GasBudget is the unified gas-state structure used throughout the EVM. It carries two pairs of fields:

  • RegularGas / StateGas: the running balance during execution, or the leftover balance the caller must absorb after a sub-call.
  • UsedRegularGas / UsedStateGas: per-frame accumulators tracking gross consumption. UsedStateGas is signed so it can be decremented by inline state-gas refunds (e.g., SSTORE 0->A->0).

The same struct serves three roles:

  • During execution: Charge / ChargeRegular / ChargeState / RefundState and RefundRegular mutate the running balance and the usage accumulators in lockstep.

  • At frame exit: ExitSuccess / ExitRevert / ExitHalt produce a new GasBudget in "leftover" form that packages the result for the caller.

  • At absorption: the caller's Absorb method merges the child's leftover budget into its own running budget.

func NewGasBudget added in v1.17.3 

func NewGasBudget(regular, state uint64) GasBudget

NewGasBudget initializes a fresh GasBudget for execution / forwarding, with both usage accumulators set to zero.

func RunPrecompiledContract added in v1.5.6 

func RunPrecompiledContract(stateDB StateDB, p PrecompiledContract, address common.Address, input []byte, gas GasBudget, logger *tracing.Hooks, rules params.Rules) (ret []byte, remaining GasBudget, err error)

RunPrecompiledContract runs and evaluates the output of a precompiled contract. It returns - the returned bytes, - the remaining gas budget, - any error that occurred

func (*GasBudget) Absorb added in v1.17.4 

func (g *GasBudget) Absorb(child GasBudget, forwarded uint64)

Absorb merges a sub-call's leftover GasBudget into this (caller's) running budget. Additionally, it does an EIP-8037 spillover correction: state-gas that spilled into the regular pool inside the child frame is excluded from the UsedRegularGas. 

spillover = forwarded - child.RegularGas - child.UsedRegularGas

forwarded is the regular-gas amount that was passed to the child at call entry (i.e., the regular initial of the child's GasBudget).

func (GasBudget) AsTracing added in v1.17.4 

func (g GasBudget) AsTracing() tracing.Gas

AsTracing converts the GasBudget into the tracing-facing Gas vector.

func (GasBudget) CanAfford added in v1.17.3 

func (g GasBudget) CanAfford(cost GasCosts) bool

CanAfford reports whether the running balance can cover the given cost. State-gas charges that exceed the reservoir spill into regular gas.

func (*GasBudget) Charge added in v1.17.3 

func (g *GasBudget) Charge(cost GasCosts) (GasBudget, bool)

Charge deducts a combined regular+state cost from the running balance and updates the usage accumulators. State-gas in excess of the reservoir spills into regular_gas.

func (*GasBudget) ChargeRegular added in v1.17.4 

func (g *GasBudget) ChargeRegular(r uint64) (GasBudget, bool)

ChargeRegular is a convenience that deducts a regular-only cost.

func (*GasBudget) ChargeState added in v1.17.4 

func (g *GasBudget) ChargeState(s uint64) (GasBudget, bool)

ChargeState is a convenience that deducts a state-only cost (spills to regular when the reservoir is exhausted). Returns false on OOG.

func (GasBudget) Exit added in v1.17.4 

func (g GasBudget) Exit(err error, initStateReservoir uint64) GasBudget

Exit dispatches on err to the appropriate exit-form constructor for the post-evm.Run path:

  • err == nil → ExitSuccess
  • err == ErrExecutionReverted → ExitRevert
  • any other err → ExitHalt

Soft validation failures (occurring BEFORE evm.Run) should call Preserved directly instead of going through this dispatcher.

func (GasBudget) ExitHalt added in v1.17.4 

func (g GasBudget) ExitHalt(initStateReservoir uint64) GasBudget

ExitHalt produces the leftover for an exceptional halt.

- state_gas_reservoir is reset back to its value at the start of the child frame - the gas_left initially given to the child is consumed (set to zero)

func (GasBudget) ExitRevert added in v1.17.4 

func (g GasBudget) ExitRevert() GasBudget

ExitRevert produces the leftover for a REVERT exit. Per EIP-8037, all state gas charged by the reverted frame is refunded to the caller's reservoir: 

leftover.StateGas = StateGas + UsedStateGas

UsedStateGas is reset since the frame's state changes are discarded.

func (GasBudget) ExitSuccess added in v1.17.4 

func (g GasBudget) ExitSuccess() GasBudget

ExitSuccess produces the leftover form for a successful frame. Inline state-gas refunds have already been folded into StateGas / UsedStateGas during execution; the running budget IS the exit budget on success.

func (*GasBudget) Forward added in v1.17.4 

func (g *GasBudget) Forward(regular uint64) GasBudget

Forward drains `regular` regular gas and the entire state reservoir from the parent's running budget and returns the initial GasBudget for a child frame. The parent's UsedRegularGas is bumped by the forwarded amount so that the absorb-on-return path correctly reclaims the unused portion.

Used by frame boundaries where the regular forward has NOT been pre- deducted: tx-level dispatch (state_transition) and CREATE / CREATE2. The CALL family pre-deducts the forward via the dynamic gas table for tracer- reporting reasons and therefore constructs its child budget directly.

Caller must ensure `regular` does not exceed the running balance and apply any EIP-150 1/64 retention before calling Forward.

func (*GasBudget) ForwardAll added in v1.17.4 

func (g *GasBudget) ForwardAll() GasBudget

ForwardAll forwards the parent's full remaining budget (both regular and state) to a child frame. Equivalent to Forward(g.RegularGas) — used at the tx boundary where there is no 1/64 retention.

func (*GasBudget) IsZero added in v1.17.4 

func (g *GasBudget) IsZero() bool

IsZero returns an indicator if the gas budget has been exhausted.

func (*GasBudget) RefundState added in v1.17.4 

func (g *GasBudget) RefundState(s uint64)

RefundState applies an inline state-gas refund (e.g., SSTORE 0->A->0). The reservoir is credited and the signed usage counter is decremented in lockstep, preserving the per-frame invariant: 

StateGas + UsedStateGas == initialStateGas + spillover_so_far

which the revert path relies on for the correct gross refund.

func (GasBudget) String added in v1.17.3 

func (g GasBudget) String() string

String returns a visual representation of the budget.

func (GasBudget) Used added in v1.17.3 

func (g GasBudget) Used(initial GasBudget) uint64

Used returns the total scalar gas consumed relative to an initial budget (= (initial.regular + initial.state) − (current.regular + current.state)). This is the payment scalar (EIP-8037's tx_gas_used_before_refund).

type GasCosts added in v1.17.3 

type GasCosts struct {
	RegularGas uint64
	StateGas   uint64
}

GasCosts denotes a vector of gas costs in the multidimensional metering paradigm. It represents the cost charged by an individual operation.

func (GasCosts) String added in v1.17.3 

func (g GasCosts) String() string

String returns a visual representation of the gas vector.

func (GasCosts) Sum added in v1.17.3 

func (g GasCosts) Sum() uint64

Sum returns the total gas (regular + state).

type GetHashFunc added in v1.5.5 

type GetHashFunc func(uint64) common.Hash

GetHashFunc returns the n'th block hash in the blockchain and is used by the BLOCKHASH EVM op code.

type JumpDestCache added in v1.16.2 

type JumpDestCache interface {
	// Load retrieves the cached jumpdest analysis for the given code hash.
	// Returns the BitVec and true if found, or nil and false if not cached.
	Load(codeHash common.Hash) (BitVec, bool)

	// Store saves the jumpdest analysis for the given code hash.
	Store(codeHash common.Hash, vec BitVec)
}

JumpDestCache represents the cache of jumpdest analysis results.

type JumpTable added in v1.9.2 

type JumpTable [256]*operation

JumpTable contains the EVM opcodes supported at a given fork.

func LookupInstructionSet added in v1.11.6 

func LookupInstructionSet(rules params.Rules) (JumpTable, error)

LookupInstructionSet returns the instruction set for the fork configured by the rules.

type Memory 

type Memory struct {
	// contains filtered or unexported fields
}

Memory implements a simple memory model for the ethereum virtual machine.

func NewMemory 

func NewMemory() *Memory

NewMemory returns a new memory model.

func (*Memory) Copy added in v1.12.1 

func (m *Memory) Copy(dst, src, len uint64)

Copy copies data from the src position slice into the dst position. The source and destination may overlap. OBS: This operation assumes that any necessary memory expansion has already been performed, and this method may panic otherwise.

func (*Memory) Data 

func (m *Memory) Data() []byte

Data returns the backing slice

func (*Memory) Free added in v1.14.9 

func (m *Memory) Free()

Free returns the memory to the pool.

func (*Memory) GetCopy added in v1.9.7 

func (m *Memory) GetCopy(offset, size uint64) (cpy []byte)

GetCopy returns offset + size as a new slice

func (*Memory) GetPtr added in v0.9.23 

func (m *Memory) GetPtr(offset, size uint64) []byte

GetPtr returns the offset + size

func (*Memory) Len 

func (m *Memory) Len() int

Len returns the length of the backing slice

func (*Memory) Resize 

func (m *Memory) Resize(size uint64)

Resize grows the memory to the requested size.

func (*Memory) Set 

func (m *Memory) Set(offset, size uint64, value []byte)

Set sets offset + size to value

func (*Memory) Set32 added in v1.8.12 

func (m *Memory) Set32(offset uint64, val *uint256.Int)

Set32 sets the 32 bytes starting at offset to the value of val, left-padded with zeroes to 32 bytes.

type OpCode 

type OpCode byte

OpCode is an EVM opcode 

const (
	STOP       OpCode = 0x0
	ADD        OpCode = 0x1
	MUL        OpCode = 0x2
	SUB        OpCode = 0x3
	DIV        OpCode = 0x4
	SDIV       OpCode = 0x5
	MOD        OpCode = 0x6
	SMOD       OpCode = 0x7
	ADDMOD     OpCode = 0x8
	MULMOD     OpCode = 0x9
	EXP        OpCode = 0xa
	SIGNEXTEND OpCode = 0xb
)

0x0 range - arithmetic ops. 

const (
	LT     OpCode = 0x10
	GT     OpCode = 0x11
	SLT    OpCode = 0x12
	SGT    OpCode = 0x13
	EQ     OpCode = 0x14
	ISZERO OpCode = 0x15
	AND    OpCode = 0x16
	OR     OpCode = 0x17
	XOR    OpCode = 0x18
	NOT    OpCode = 0x19
	BYTE   OpCode = 0x1a
	SHL    OpCode = 0x1b
	SHR    OpCode = 0x1c
	SAR    OpCode = 0x1d
	CLZ    OpCode = 0x1e
)

0x10 range - comparison ops. 

const (
	ADDRESS        OpCode = 0x30
	BALANCE        OpCode = 0x31
	ORIGIN         OpCode = 0x32
	CALLER         OpCode = 0x33
	CALLVALUE      OpCode = 0x34
	CALLDATALOAD   OpCode = 0x35
	CALLDATASIZE   OpCode = 0x36
	CALLDATACOPY   OpCode = 0x37
	CODESIZE       OpCode = 0x38
	CODECOPY       OpCode = 0x39
	GASPRICE       OpCode = 0x3a
	EXTCODESIZE    OpCode = 0x3b
	EXTCODECOPY    OpCode = 0x3c
	RETURNDATASIZE OpCode = 0x3d
	RETURNDATACOPY OpCode = 0x3e
	EXTCODEHASH    OpCode = 0x3f
)

0x30 range - closure state. 

const (
	BLOCKHASH   OpCode = 0x40
	COINBASE    OpCode = 0x41
	TIMESTAMP   OpCode = 0x42
	NUMBER      OpCode = 0x43
	DIFFICULTY  OpCode = 0x44
	RANDOM      OpCode = 0x44 // Same as DIFFICULTY
	PREVRANDAO  OpCode = 0x44 // Same as DIFFICULTY
	GASLIMIT    OpCode = 0x45
	CHAINID     OpCode = 0x46
	SELFBALANCE OpCode = 0x47
	BASEFEE     OpCode = 0x48
	BLOBHASH    OpCode = 0x49
	BLOBBASEFEE OpCode = 0x4a
	SLOTNUM     OpCode = 0x4b
)

0x40 range - block operations. 

const (
	POP      OpCode = 0x50
	MLOAD    OpCode = 0x51
	MSTORE   OpCode = 0x52
	MSTORE8  OpCode = 0x53
	SLOAD    OpCode = 0x54
	SSTORE   OpCode = 0x55
	JUMP     OpCode = 0x56
	JUMPI    OpCode = 0x57
	PC       OpCode = 0x58
	MSIZE    OpCode = 0x59
	GAS      OpCode = 0x5a
	JUMPDEST OpCode = 0x5b
	TLOAD    OpCode = 0x5c
	TSTORE   OpCode = 0x5d
	MCOPY    OpCode = 0x5e
	PUSH0    OpCode = 0x5f
)

0x50 range - 'storage' and execution. 

const (
	PUSH1 OpCode = 0x60 + iota
	PUSH2
	PUSH3
	PUSH4
	PUSH5
	PUSH6
	PUSH7
	PUSH8
	PUSH9
	PUSH10
	PUSH11
	PUSH12
	PUSH13
	PUSH14
	PUSH15
	PUSH16
	PUSH17
	PUSH18
	PUSH19
	PUSH20
	PUSH21
	PUSH22
	PUSH23
	PUSH24
	PUSH25
	PUSH26
	PUSH27
	PUSH28
	PUSH29
	PUSH30
	PUSH31
	PUSH32
)

0x60 range - pushes. 

const (
	DUP1 OpCode = 0x80 + iota
	DUP2
	DUP3
	DUP4
	DUP5
	DUP6
	DUP7
	DUP8
	DUP9
	DUP10
	DUP11
	DUP12
	DUP13
	DUP14
	DUP15
	DUP16
)

0x80 range - dups. 

const (
	SWAP1 OpCode = 0x90 + iota
	SWAP2
	SWAP3
	SWAP4
	SWAP5
	SWAP6
	SWAP7
	SWAP8
	SWAP9
	SWAP10
	SWAP11
	SWAP12
	SWAP13
	SWAP14
	SWAP15
	SWAP16
)

0x90 range - swaps. 

const (
	LOG0 OpCode = 0xa0 + iota
	LOG1
	LOG2
	LOG3
	LOG4
)

0xa0 range - logging ops. 

const (
	DATALOAD  OpCode = 0xd0
	DATALOADN OpCode = 0xd1
	DATASIZE  OpCode = 0xd2
	DATACOPY  OpCode = 0xd3
)

0xd0 range - eof operations. 

const (
	RJUMP          OpCode = 0xe0
	RJUMPI         OpCode = 0xe1
	RJUMPV         OpCode = 0xe2
	CALLF          OpCode = 0xe3
	RETF           OpCode = 0xe4
	JUMPF          OpCode = 0xe5
	DUPN           OpCode = 0xe6
	SWAPN          OpCode = 0xe7
	EXCHANGE       OpCode = 0xe8
	EOFCREATE      OpCode = 0xec
	RETURNCONTRACT OpCode = 0xee
)

0xe0 range - eof operations. 

const (
	CREATE       OpCode = 0xf0
	CALL         OpCode = 0xf1
	CALLCODE     OpCode = 0xf2
	RETURN       OpCode = 0xf3
	DELEGATECALL OpCode = 0xf4
	CREATE2      OpCode = 0xf5

	RETURNDATALOAD  OpCode = 0xf7
	EXTCALL         OpCode = 0xf8
	EXTDELEGATECALL OpCode = 0xf9

	STATICCALL    OpCode = 0xfa
	EXTSTATICCALL OpCode = 0xfb
	REVERT        OpCode = 0xfd
	INVALID       OpCode = 0xfe
	SELFDESTRUCT  OpCode = 0xff
)

0xf0 range - closures. 

const (
	KECCAK256 OpCode = 0x20
)

0x20 range - crypto.

func StringToOp added in v0.9.38 

func StringToOp(str string) OpCode

StringToOp finds the opcode whose name is stored in `str`.

func (OpCode) IsPush added in v1.3.1 

func (op OpCode) IsPush() bool

IsPush specifies if an opcode is a PUSH opcode. @deprecated: this method is often used in order to know if there are immediates. Please use `vm.Immediates` instead.

func (OpCode) String 

func (op OpCode) String() string

type PrecompiledContract added in v1.5.6 

type PrecompiledContract interface {
	RequiredGas(input []byte) uint64  // RequiredPrice calculates the contract gas use
	Run(input []byte) ([]byte, error) // Run runs the precompiled contract
	Name() string
}

PrecompiledContract is the basic interface for native Go contracts. The implementation requires a deterministic gas count based on the input size of the Run method of the contract.

type PrecompiledContracts 

type PrecompiledContracts map[common.Address]PrecompiledContract

PrecompiledContracts contains the precompiled contracts supported at the given fork.

func ActivePrecompiledContracts added in v1.14.9 

func ActivePrecompiledContracts(rules params.Rules) PrecompiledContracts

ActivePrecompiledContracts returns a copy of precompiled contracts enabled with the current configuration.

type ScopeContext added in v1.10.2 

type ScopeContext struct {
	Memory   *Memory
	Stack    *Stack
	Contract *Contract
}

ScopeContext contains the things that are per-call, such as stack and memory, but not transients like pc and gas

func (*ScopeContext) Address added in v1.14.0 

func (ctx *ScopeContext) Address() common.Address

Address returns the address where this scope of execution is taking place.

func (*ScopeContext) CallInput added in v1.14.0 

func (ctx *ScopeContext) CallInput() []byte

CallInput returns the input/calldata with this call. Callers must not modify the contents of the returned data.

func (*ScopeContext) CallValue added in v1.14.0 

func (ctx *ScopeContext) CallValue() *uint256.Int

CallValue returns the value supplied with this call.

func (*ScopeContext) Caller added in v1.14.0 

func (ctx *ScopeContext) Caller() common.Address

Caller returns the current caller.

func (*ScopeContext) ContractCode added in v1.14.10 

func (ctx *ScopeContext) ContractCode() []byte

ContractCode returns the code of the contract being executed.

func (*ScopeContext) MemoryData added in v1.14.0 

func (ctx *ScopeContext) MemoryData() []byte

MemoryData returns the underlying memory slice. Callers must not modify the contents of the returned data.

func (*ScopeContext) StackData added in v1.14.0 

func (ctx *ScopeContext) StackData() []uint256.Int

StackData returns the stack data. Callers must not modify the contents of the returned data.

type Stack added in v1.5.0 

type Stack struct {
	// contains filtered or unexported fields
}

Stack is an object for basic stack operations. Items popped to the stack are expected to be changed and modified. stack does not take care of adding newly initialized objects.

func (*Stack) Data added in v1.5.0 

func (s *Stack) Data() []uint256.Int

Data returns the underlying uint256.Int array.

type StateDB added in v1.5.5 

type StateDB interface {
	CreateAccount(common.Address)
	CreateContract(common.Address)

	SubBalance(common.Address, *uint256.Int, tracing.BalanceChangeReason) uint256.Int
	AddBalance(common.Address, *uint256.Int, tracing.BalanceChangeReason) uint256.Int
	GetBalance(common.Address) *uint256.Int

	GetNonce(common.Address) uint64
	SetNonce(common.Address, uint64, tracing.NonceChangeReason)

	GetCodeHash(common.Address) common.Hash
	GetCode(common.Address) []byte

	// SetCode sets the new code for the address, and returns the previous code, if any.
	SetCode(common.Address, []byte, tracing.CodeChangeReason) []byte
	GetCodeSize(common.Address) int

	AddRefund(uint64)
	SubRefund(uint64)
	GetRefund() uint64

	GetStateAndCommittedState(common.Address, common.Hash) (common.Hash, common.Hash)
	GetState(common.Address, common.Hash) common.Hash
	SetState(common.Address, common.Hash, common.Hash) common.Hash

	GetTransientState(addr common.Address, key common.Hash) common.Hash
	SetTransientState(addr common.Address, key, value common.Hash)

	SelfDestruct(common.Address)
	HasSelfDestructed(common.Address) bool

	// Exist reports whether the given account exists in state.
	// Notably this also returns true for self-destructed accounts within the current transaction.
	Exist(common.Address) bool

	// Touch accesses the state without returning anything.
	Touch(common.Address)

	// IsNewContract reports whether the contract at the given address was deployed
	// during the current transaction.
	IsNewContract(addr common.Address) bool

	// Empty returns whether the given account is empty. Empty
	// is defined according to EIP161 (balance = nonce = code = 0).
	Empty(common.Address) bool

	AddressInAccessList(addr common.Address) bool
	SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)
	// AddAddressToAccessList adds the given address to the access list. This operation is safe to perform
	// even if the feature/fork is not active yet
	AddAddressToAccessList(addr common.Address)
	// AddSlotToAccessList adds the given (address,slot) to the access list. This operation is safe to perform
	// even if the feature/fork is not active yet
	AddSlotToAccessList(addr common.Address, slot common.Hash)

	Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)

	RevertToSnapshot(int)
	Snapshot() int

	AddLog(*types.Log)
	LogsForBurnAccounts() []*types.Log
	AddPreimage(common.Hash, []byte)

	Witness() *stateless.Witness

	AccessEvents() *state.AccessEvents

	// Finalise must be invoked at the end of a transaction
	Finalise(bool) *bal.ConstructionBlockAccessList
	SetTxContext(thash common.Hash, ti int, blockAccessIndex uint32)
}

StateDB is an EVM database for full state querying.

type TransferFunc added in v1.5.5 

type TransferFunc func(StateDB, common.Address, common.Address, *uint256.Int, *params.Rules)

TransferFunc is the signature of a transfer function

type TxContext added in v1.9.25 

type TxContext struct {
	// Message information
	Origin       common.Address      // Provides information for ORIGIN
	GasPrice     *uint256.Int        // Provides information for GASPRICE (and is used to zero the basefee if NoBaseFee is set)
	BlobHashes   []common.Hash       // Provides information for BLOBHASH
	AccessEvents *state.AccessEvents // Capture all state accesses for this tx
}

TxContext provides the EVM with information about a transaction. All fields can change between transactions.

type VMError added in v1.14.0 

type VMError struct {
	// contains filtered or unexported fields
}

VMError wraps a VM error with an additional stable error code. The error field is the original error that caused the VM error and must be one of the VM error defined at the top of this file.

If the error is not one of the known error above, the error code will be set to VMErrorCodeUnknown.

func (*VMError) Error added in v1.14.0 

func (e *VMError) Error() string

func (*VMError) ErrorCode added in v1.14.0 

func (e *VMError) ErrorCode() int

func (*VMError) Unwrap added in v1.14.0 

func (e *VMError) Unwrap() error

Source Files

View all Source files

Directories

Path Synopsis
Package runtime provides a basic execution model for executing EVM code.
 Package runtime provides a basic execution model for executing EVM code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.