vm

package
v1.13.2 Latest Latest
Warning

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

 Go to latest Published: Sep 20, 2025 License: GPL-3.0 Imports: 31 Imported by: 0

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.

Index

Constants

View Source 
const (
	AccessWitnessReadFlag  = mode(1)
	AccessWitnessWriteFlag = mode(2)
)
View Source 
const (
	Blake2FInputLength        = 213
	Blake2FFinalBlockBytes    = byte(1)
	Blake2FNonFinalBlockBytes = byte(0)
)
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

View Source 
const (
	MaxStackHeight = 1023
)

Variables

View Source 
var (
	PrecompiledAddressesPrague    []common.Address
	PrecompiledAddressesCancun    []common.Address
	PrecompiledAddressesBerlin    []common.Address
	PrecompiledAddressesIstanbul  []common.Address
	PrecompiledAddressesByzantium []common.Address
	PrecompiledAddressesHomestead []common.Address
)
View Source 
var (
	ErrTruncatedImmediate = errors.New("truncated immediate")

	ErrInvalidJumpDest = errors.New("invalid jump destination")

	ErrInvalidOutputs         = errors.New("invalid number of outputs")
	ErrInvalidMaxStackHeight  = errors.New("invalid max stack height")
	ErrInvalidCodeTermination = errors.New("invalid code termination")

	ErrUnreachableCode = errors.New("unreachable code")
)

Below are all possible errors that can occur during validation of EOF containers.

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 (
	PragueInstructionSet = newPragueInstructionSet()
	EofInstructionSet    = newEOFInstructionSetForTesting()
)
View Source 
var (
	GasMcopy = memoryCopierGas(2)
)
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},
	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},
	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},
	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},
	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 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},
	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 

func ActivateableEips() []string

func ActivePrecompiles 

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

ActivePrecompiles returns the precompile addresses enabled with the current configuration.

func EnableEIP 

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 HasEOFByte 

func HasEOFByte(code []byte) bool

HasEOFByte returns true if code starts with 0xEF byte

func Immediates 

func Immediates(op OpCode) int

Immediates returns the number bytes of immediates (argument not from stack but from code) a given opcode has. OBS:

  • This function assumes EOF instruction-set. It cannot be upon in a. pre-EOF code b. post-EOF but legacy code
  • RJUMPV is unique as it has a variable sized operand. The total size is determined by the count byte which immediately follows RJUMPV. This method will return '3' for RJUMPV, which is the minimum.

func MemoryGasCost 

func MemoryGasCost(mem *Memory, newMemSize uint64) (uint64, error)

MemoryGasCost calculates the quadratic gas for memory expansion. It does so only for the memory region that is expanded, not the total memory.

func MemoryMcopy 

func MemoryMcopy(stack *Stack) (uint64, bool)

func OpAdd 

func OpAdd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpAddmod 

func OpAddmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpAddress 

func OpAddress(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpAnd 

func OpAnd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpBlobHash 

func OpBlobHash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

OpBlobHash implements the BLOBHASH opcode

func OpByte 

func OpByte(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpDiv 

func OpDiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpEq 

func OpEq(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpExp 

func OpExp(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpGt 

func OpGt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpIszero 

func OpIszero(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpKeccak256 

func OpKeccak256(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpLt 

func OpLt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpMcopy 

func OpMcopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

OpMcopy implements the MCOPY opcode (https://eips.ethereum.org/EIPS/eip-5656)

func OpMod 

func OpMod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpMstore 

func OpMstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpMstore8 

func OpMstore8(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpMul 

func OpMul(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpMulmod 

func OpMulmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpOr 

func OpOr(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpOrigin 

func OpOrigin(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpRandom 

func OpRandom(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpSAR 

func OpSAR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

OpSAR implements Arithmetic Shift Right The SAR instruction (arithmetic shift right) pops 2 values from the stack, first arg1 and then arg2, and pushes on the stack arg2 shifted to the right by arg1 number of bits with sign extension.

func OpSHL 

func OpSHL(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

OpSHL implements Shift Left The SHL instruction (shift left) pops 2 values from the stack, first arg1 and then arg2, and pushes on the stack arg2 shifted to the left by arg1 number of bits.

func OpSHR 

func OpSHR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

OpSHR implements Logical Shift Right The SHR instruction (logical shift right) pops 2 values from the stack, first arg1 and then arg2, and pushes on the stack arg2 shifted to the right by arg1 number of bits with zero fill.

func OpSdiv 

func OpSdiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpSgt 

func OpSgt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpSignExtend 

func OpSignExtend(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpSlt 

func OpSlt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpSmod 

func OpSmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpSub 

func OpSub(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func OpTload 

func OpTload(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

OpTload implements TLOAD opcode

func OpTstore 

func OpTstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

OpTstore implements TSTORE opcode

func OpXor 

func OpXor(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error)

func RunPrecompiledContract 

func RunPrecompiledContract(p PrecompiledContract, evm *EVM, sender common.Address, callingContract common.Address, input []byte, suppliedGas uint64, value *big.Int, logger *tracing.Hooks, readOnly bool, isFromDelegateCall bool) (ret []byte, remainingGas uint64, err error)

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

func ToWordSize 

func ToWordSize(size uint64) uint64

ToWordSize returns the ceiled word size required for memory expansion.

func VMErrorFromErr 

func VMErrorFromErr(err error) error

func ValidEip 

func ValidEip(eipNum int) bool

func ValidateCode 

func ValidateCode(code []byte, section int, container *Container, jt *JumpTable, isInitCode bool) (*validationResult, error)

validateCode validates the code parameter against the EOF v1 validity requirements.

Types

type AccessEvents 

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

AccessEvents lists the locations of the state that are being accessed during the production of a block.

func NewAccessEvents 

func NewAccessEvents(pointCache *utils.PointCache) *AccessEvents

func (*AccessEvents) AddAccount 

func (ae *AccessEvents) AddAccount(addr common.Address, isWrite bool, availableGas uint64) uint64

AddAccount returns the gas to be charged for each of the currently cold member fields of an account.

func (*AccessEvents) AddTxDestination 

func (ae *AccessEvents) AddTxDestination(addr common.Address, sendsValue, doesntExist bool)

AddTxDestination adds the member fields of the sender account to the access event list, so that cold accesses are not charged, since they are covered by the 21000 gas.

func (*AccessEvents) AddTxOrigin 

func (ae *AccessEvents) AddTxOrigin(originAddr common.Address)

AddTxOrigin adds the member fields of the sender account to the access event list, so that cold accesses are not charged, since they are covered by the 21000 gas.

func (*AccessEvents) BasicDataGas 

func (ae *AccessEvents) BasicDataGas(addr common.Address, isWrite bool, availableGas uint64, chargeWarmCosts bool) uint64

BasicDataGas adds the account's basic data to the accessed data, and returns the amount of gas that it costs. Note that an access in write mode implies an access in read mode, whereas an access in read mode does not imply an access in write mode.

func (*AccessEvents) CodeChunksRangeGas 

func (ae *AccessEvents) CodeChunksRangeGas(contractAddr common.Address, startPC, size uint64, codeLen uint64, isWrite bool, availableGas uint64) (uint64, uint64)

CodeChunksRangeGas is a helper function to touch every chunk in a code range and charge witness gas costs

func (*AccessEvents) CodeHashGas 

func (ae *AccessEvents) CodeHashGas(addr common.Address, isWrite bool, availableGas uint64, chargeWarmCosts bool) uint64

CodeHashGas adds the account's code hash to the accessed data, and returns the amount of gas that it costs. in write mode. If false, the charged gas corresponds to an access in read mode. Note that an access in write mode implies an access in read mode, whereas an access in read mode does not imply an access in write mode.

func (*AccessEvents) ContractCreateInitGas 

func (ae *AccessEvents) ContractCreateInitGas(addr common.Address, availableGas uint64) (uint64, uint64)

ContractCreateInitGas returns the access gas costs for the initialization of a contract creation.

func (*AccessEvents) ContractCreatePreCheckGas 

func (ae *AccessEvents) ContractCreatePreCheckGas(addr common.Address, availableGas uint64) uint64

ContractCreatePreCheckGas charges access costs before a contract creation is initiated. It is just reads, because the address collision is done before the transfer, and so no write are guaranteed to happen at this point.

func (*AccessEvents) Copy 

func (ae *AccessEvents) Copy() *AccessEvents

func (*AccessEvents) Keys 

func (ae *AccessEvents) Keys() [][]byte

Keys returns, predictably, the list of keys that were touched during the buildup of the access witness.

func (*AccessEvents) Merge 

func (ae *AccessEvents) Merge(other *AccessEvents)

Merge is used to merge the access events that were generated during the execution of a tx, with the accumulation of all access events that were generated during the execution of all txs preceding this one in a block.

func (*AccessEvents) MessageCallGas 

func (ae *AccessEvents) MessageCallGas(destination common.Address, availableGas uint64) uint64

MessageCallGas returns the gas to be charged for each of the currently cold member fields of an account, that need to be touched when making a message call to that account.

func (*AccessEvents) SlotGas 

func (ae *AccessEvents) SlotGas(addr common.Address, slot common.Hash, isWrite bool, availableGas uint64, chargeWarmCosts bool) uint64

SlotGas returns the amount of gas to be charged for a cold storage access.

func (*AccessEvents) ValueTransferGas 

func (ae *AccessEvents) ValueTransferGas(callerAddr, targetAddr common.Address, availableGas uint64) uint64

ValueTransferGas returns the gas to be charged for each of the currently cold balance member fields of the caller and the callee accounts.

type BigModExp 

type BigModExp struct {
	Eip2565 bool
	// contains filtered or unexported fields
}

BigModExp implements a native big integer exponential modular operation.

func (*BigModExp) RequiredGas 

func (c *BigModExp) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*BigModExp) Run 

func (c *BigModExp) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bitvec 

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).

func CodeBitmap 

func CodeBitmap(code []byte) Bitvec

codeBitmap collects data locations in code.

func CodeBitmapInternal 

func CodeBitmapInternal(code, bits Bitvec) Bitvec

codeBitmapInternal is the internal implementation of codeBitmap. It exists for the purpose of being able to run benchmark tests without dynamic allocations affecting the results.

func EofCodeBitmapInternal 

func EofCodeBitmapInternal(code, bits Bitvec) Bitvec

eofCodeBitmapInternal is the internal implementation of codeBitmap for EOF code validation.

type Blake2F 

type Blake2F struct{}

func (*Blake2F) RequiredGas 

func (c *Blake2F) RequiredGas(input []byte) uint64

func (*Blake2F) Run 

func (c *Blake2F) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type BlockContext 

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
}

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

type Bls12381G1Add 

type Bls12381G1Add struct{}

Bls12381G1Add implements EIP-2537 G1Add precompile.

func (*Bls12381G1Add) RequiredGas 

func (c *Bls12381G1Add) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bls12381G1Add) Run 

func (c *Bls12381G1Add) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bls12381G1MultiExp 

type Bls12381G1MultiExp struct{}

Bls12381G1MultiExp implements EIP-2537 G1MultiExp precompile.

func (*Bls12381G1MultiExp) RequiredGas 

func (c *Bls12381G1MultiExp) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bls12381G1MultiExp) Run 

func (c *Bls12381G1MultiExp) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bls12381G2Add 

type Bls12381G2Add struct{}

Bls12381G2Add implements EIP-2537 G2Add precompile.

func (*Bls12381G2Add) RequiredGas 

func (c *Bls12381G2Add) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bls12381G2Add) Run 

func (c *Bls12381G2Add) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bls12381G2MultiExp 

type Bls12381G2MultiExp struct{}

Bls12381G2MultiExp implements EIP-2537 G2MultiExp precompile.

func (*Bls12381G2MultiExp) RequiredGas 

func (c *Bls12381G2MultiExp) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bls12381G2MultiExp) Run 

func (c *Bls12381G2MultiExp) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bls12381MapG1 

type Bls12381MapG1 struct{}

Bls12381MapG1 implements EIP-2537 MapG1 precompile.

func (*Bls12381MapG1) RequiredGas 

func (c *Bls12381MapG1) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bls12381MapG1) Run 

func (c *Bls12381MapG1) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bls12381MapG2 

type Bls12381MapG2 struct{}

Bls12381MapG2 implements EIP-2537 MapG2 precompile.

func (*Bls12381MapG2) RequiredGas 

func (c *Bls12381MapG2) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bls12381MapG2) Run 

func (c *Bls12381MapG2) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bls12381Pairing 

type Bls12381Pairing struct{}

Bls12381Pairing implements EIP-2537 Pairing precompile.

func (*Bls12381Pairing) RequiredGas 

func (c *Bls12381Pairing) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bls12381Pairing) Run 

func (c *Bls12381Pairing) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bn256AddIstanbul 

type Bn256AddIstanbul struct{}

Bn256AddIstanbul implements a native elliptic curve point addition conforming to Istanbul consensus rules.

func (*Bn256AddIstanbul) RequiredGas 

func (c *Bn256AddIstanbul) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bn256AddIstanbul) Run 

func (c *Bn256AddIstanbul) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bn256PairingIstanbul 

type Bn256PairingIstanbul struct{}

Bn256PairingIstanbul implements a pairing pre-compile for the bn256 curve conforming to Istanbul consensus rules.

func (*Bn256PairingIstanbul) RequiredGas 

func (c *Bn256PairingIstanbul) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bn256PairingIstanbul) Run 

func (c *Bn256PairingIstanbul) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Bn256ScalarMulIstanbul 

type Bn256ScalarMulIstanbul struct{}

Bn256ScalarMulIstanbul implements a native elliptic curve scalar multiplication conforming to Istanbul consensus rules.

func (*Bn256ScalarMulIstanbul) RequiredGas 

func (c *Bn256ScalarMulIstanbul) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

func (*Bn256ScalarMulIstanbul) Run 

func (c *Bn256ScalarMulIstanbul) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type CanTransferFunc 

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

CanTransferFunc is the signature of a transfer guard function

type Config 

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

	StatelessSelfValidation bool // Generate execution witnesses and self-check against them (testing purpose)
}

Config are the configuration options for the Interpreter

type Container 

type Container struct {
	Types             []*FunctionMetadata
	CodeSections      [][]byte
	SubContainers     []*Container
	SubContainerCodes [][]byte
	Data              []byte
	DataSize          int // might be more than len(data)
}

Container is an EOF container object.

func (*Container) MarshalBinary 

func (c *Container) MarshalBinary() []byte

MarshalBinary encodes an EOF container into binary format.

func (*Container) String 

func (c *Container) String() string

func (*Container) UnmarshalBinary 

func (c *Container) UnmarshalBinary(b []byte, isInitcode bool) error

UnmarshalBinary decodes an EOF container.

func (*Container) UnmarshalSubContainer 

func (c *Container) UnmarshalSubContainer(b []byte, isInitcode bool) error

UnmarshalSubContainer decodes an EOF container that is inside another container.

func (*Container) ValidateCode 

func (c *Container) ValidateCode(jt *JumpTable, isInitCode bool) error

ValidateCode validates each code section of the container against the EOF v1 rule set.

type Contract 

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 uint64
	// 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 

func NewContract(caller common.Address, address common.Address, value *uint256.Int, gas uint64, jumpDests map[common.Hash]Bitvec) *Contract

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

func (*Contract) Address 

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

Address returns the contracts address

func (*Contract) Caller 

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 

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

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

func (*Contract) RefundGas 

func (c *Contract) RefundGas(gas uint64, logger *tracing.Hooks, reason tracing.GasChangeReason)

RefundGas refunds gas to the contract

func (*Contract) SetCallCode 

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

SetCallCode sets the code of the contract,

func (*Contract) UseGas 

func (c *Contract) UseGas(gas uint64, logger *tracing.Hooks, reason tracing.GasChangeReason) (ok bool)

UseGas attempts the use gas and subtracts it and returns true on success

func (*Contract) Value 

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

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

type DataCopy 

type DataCopy struct{}

data copy implemented as a native contract.

func (*DataCopy) RequiredGas 

func (c *DataCopy) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

This method does not require any overflow checking as the input size gas costs required for anything significant is so high it's impossible to pay for.

func (*DataCopy) Run 

func (c *DataCopy) Run(_ *EVM, _ common.Address, _ common.Address, in []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type DynamicGasPrecompiledContract 

type DynamicGasPrecompiledContract interface {
	RunAndCalculateGas(evm *EVM, sender common.Address, callingContract common.Address, input []byte, suppliedGas uint64, value *big.Int, hooks *tracing.Hooks, readOnly bool, isFromDelegateCall bool) (ret []byte, remainingGas uint64, err error) // Run runs the precompiled contract and calculate gas dynamically
}

type EVM 

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 

func NewEVM(blockCtx BlockContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, customPrecompiles map[common.Address]PrecompiledContract) *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 

func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, gas uint64, value *uint256.Int) (ret []byte, leftOverGas uint64, 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 

func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byte, gas uint64, value *uint256.Int) (ret []byte, leftOverGas uint64, 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 

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 

func (evm *EVM) Cancelled() bool

Cancelled returns true if Cancel has been called

func (*EVM) ChainConfig 

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

ChainConfig returns the environment's chain configuration

func (*EVM) Create 

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

Create creates a new contract using code as deployment code.

func (*EVM) Create2 

func (evm *EVM) Create2(caller common.Address, code []byte, gas uint64, endowment *uint256.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, 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) CreateWithAddress 

func (evm *EVM) CreateWithAddress(caller common.Address, code []byte, gas uint64, value *big.Int, address common.Address) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)

func (*EVM) DelegateCall 

func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, addr common.Address, input []byte, gas uint64, value *uint256.Int) (ret []byte, leftOverGas uint64, 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) GetDeploymentCode 

func (evm *EVM) GetDeploymentCode(caller common.Address, code []byte, gas uint64, value *big.Int, address common.Address) ([]byte, uint64, error)

func (*EVM) GetDepth 

func (evm *EVM) GetDepth() int

func (*EVM) GetInterpreter 

func (evm *EVM) GetInterpreter() *EVMInterpreter

func (*EVM) GetPrecompiles 

func (evm *EVM) GetPrecompiles() (res []common.Address)

func (*EVM) GetVMContext 

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

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

func (*EVM) Interpreter 

func (evm *EVM) Interpreter() *EVMInterpreter

Interpreter returns the current interpreter

func (*EVM) SetPrecompiles 

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 

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 

func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, 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 EVMInterpreter 

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

EVMInterpreter represents an EVM interpreter

func NewEVMInterpreter 

func NewEVMInterpreter(evm *EVM) *EVMInterpreter

NewEVMInterpreter returns a new instance of the Interpreter.

func (*EVMInterpreter) Run 

func (in *EVMInterpreter) 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.

type Ecrecover 

type Ecrecover struct{}

Ecrecover implemented as a native contract.

func (*Ecrecover) RequiredGas 

func (c *Ecrecover) RequiredGas(input []byte) uint64

func (*Ecrecover) Run 

func (c *Ecrecover) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type ErrInvalidOpCode 

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

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

func (*ErrInvalidOpCode) Error 

func (e *ErrInvalidOpCode) Error() string

type ErrStackOverflow 

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 

func (e ErrStackOverflow) Error() string

func (ErrStackOverflow) Unwrap 

func (e ErrStackOverflow) Unwrap() error

type ErrStackUnderflow 

type ErrStackUnderflow struct {
	StackLen int
	Required int
}

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

func (ErrStackUnderflow) Error 

func (e ErrStackUnderflow) Error() string

func (ErrStackUnderflow) Unwrap 

func (e ErrStackUnderflow) Unwrap() error

type ExecutionFunc 

type ExecutionFunc func(pc *uint64, interpreter *EVMInterpreter, callContext *ScopeContext) ([]byte, error)

func MakePush 

func MakePush(size uint64, pushByteSize int) ExecutionFunc

make push instruction function

type FunctionMetadata 

type FunctionMetadata struct {
	Inputs         uint8
	Outputs        uint8
	MaxStackHeight uint16
}

FunctionMetadata is an EOF function signature.

type GetHashFunc 

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 JumpTable 

type JumpTable [256]*operation

JumpTable contains the EVM opcodes supported at a given fork.

func CopyJumpTable 

func CopyJumpTable(source *JumpTable) *JumpTable

func LookupInstructionSet 

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

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

func NewEOFInstructionSetForTesting 

func NewEOFInstructionSetForTesting() JumpTable

func NewMergeInstructionSet 

func NewMergeInstructionSet() JumpTable

type KzgPointEvaluation 

type KzgPointEvaluation struct{}

KzgPointEvaluation implements the EIP-4844 point evaluation precompile.

func (*KzgPointEvaluation) RequiredGas 

func (b *KzgPointEvaluation) RequiredGas(input []byte) uint64

RequiredGas estimates the gas required for running the point evaluation precompile.

func (*KzgPointEvaluation) Run 

func (b *KzgPointEvaluation) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

Run executes the point evaluation precompile.

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 

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 

func (m *Memory) Free()

Free returns the memory to the pool.

func (*Memory) GetCopy 

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

GetCopy returns offset + size as a new slice

func (*Memory) GetPtr 

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 resizes the memory to size

func (*Memory) Set 

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

Set sets offset + size to value

func (*Memory) Set32 

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.

func (*Memory) Store 

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

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
)

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
)

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 

func StringToOp(str string) OpCode

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

func (OpCode) IsPush 

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 

type PrecompiledContract interface {
	RequiredGas(input []byte) uint64                                                                                                                                                  // RequiredPrice calculates the contract gas use
	Run(evm *EVM, sender common.Address, callingContract common.Address, input []byte, value *big.Int, readOnly bool, isFromDelegateCall bool, logger *tracing.Hooks) ([]byte, error) // Run runs the precompiled contract
}

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 

func ActivePrecompiledContracts(rules params.Rules, customPrecompiles map[common.Address]PrecompiledContract) PrecompiledContracts

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

type Ripemd160hash 

type Ripemd160hash struct{}

RIPEMD160 implemented as a native contract.

func (*Ripemd160hash) RequiredGas 

func (c *Ripemd160hash) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

This method does not require any overflow checking as the input size gas costs required for anything significant is so high it's impossible to pay for.

func (*Ripemd160hash) Run 

func (c *Ripemd160hash) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type ScopeContext 

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 

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

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

func (*ScopeContext) CallInput 

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 

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

CallValue returns the value supplied with this call.

func (*ScopeContext) Caller 

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

Caller returns the current caller.

func (*ScopeContext) ContractCode 

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

ContractCode returns the code of the contract being executed.

func (*ScopeContext) MemoryData 

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

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

func (*ScopeContext) StackData 

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

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

type Sha256hash 

type Sha256hash struct{}

SHA256 implemented as a native contract.

func (*Sha256hash) RequiredGas 

func (c *Sha256hash) RequiredGas(input []byte) uint64

RequiredGas returns the gas required to execute the pre-compiled contract.

This method does not require any overflow checking as the input size gas costs required for anything significant is so high it's impossible to pay for.

func (*Sha256hash) Run 

func (c *Sha256hash) Run(_ *EVM, _ common.Address, _ common.Address, input []byte, _ *big.Int, _ bool, _ bool, _ *tracing.Hooks) ([]byte, error)

type Stack 

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 Newstack 

func Newstack() *Stack

func (*Stack) Back 

func (st *Stack) Back(n int) *uint256.Int

Back returns the n'th item in stack

func (*Stack) Data 

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

Data returns the underlying uint256.Int array.

func (*Stack) Len 

func (st *Stack) Len() int

func (*Stack) Peek 

func (st *Stack) Peek() *uint256.Int

func (*Stack) Pop 

func (st *Stack) Pop() (ret uint256.Int)

func (*Stack) Push 

func (st *Stack) Push(d *uint256.Int)

type StateDB 

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) []byte
	GetCodeSize(common.Address) int

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

	GetCommittedState(common.Address, common.Hash) common.Hash
	GetState(common.Address, common.Hash) common.Hash
	SetState(common.Address, common.Hash, common.Hash) common.Hash
	GetStorageRoot(addr common.Address) common.Hash

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

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

	// SelfDestruct6780 is post-EIP6780 selfdestruct, which means that it's a
	// send-all-to-beneficiary, unless the contract was created in this same
	// transaction, in which case it will be destructed.
	// This method returns the prior balance, along with a boolean which is
	// true iff the object was indeed destructed.
	SelfDestruct6780(common.Address) (uint256.Int, bool)

	// Exist reports whether the given account exists in state.
	// Notably this should also return true for self-destructed accounts.
	Exist(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)

	// PointCache returns the point cache used in computations
	PointCache() *utils.PointCache

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

	RevertToSnapshot(int)
	Snapshot() int

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

	Witness() *stateless.Witness

	AccessEvents() *AccessEvents

	// Finalise must be invoked at the end of a transaction
	Finalise(bool)

	// new methods
	Error() error
	SetBalance(common.Address, *uint256.Int, tracing.BalanceChangeReason)
	SetStorage(common.Address, map[common.Hash]common.Hash)
	Commit(block uint64, deleteEmptyObjects bool, noStorageWiping bool) (common.Hash, error)
	SetTxContext(thash common.Hash, ti int)
	Copy() StateDB
	IntermediateRoot(deleteEmptyObjects bool) common.Hash
	GetLogs(hash common.Hash, blockNumber uint64, blockHash common.Hash) []*types.Log
	TxIndex() int
	Preimages() map[common.Hash][]byte
	Logs() []*types.Log
	SetEVM(evm *EVM)
}

StateDB is an EVM database for full state querying.

type TransferFunc 

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

TransferFunc is the signature of a transfer function

type TxContext 

type TxContext struct {
	// Message information
	Origin       common.Address // Provides information for ORIGIN
	GasPrice     *big.Int       // Provides information for GASPRICE (and is used to zero the basefee if NoBaseFee is set)
	BlobHashes   []common.Hash  // Provides information for BLOBHASH
	BlobFeeCap   *big.Int       // Is used to zero the blobbasefee if NoBaseFee is set
	AccessEvents *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 

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 

func (e *VMError) Error() string

func (*VMError) ErrorCode 

func (e *VMError) ErrorCode() int

func (*VMError) Unwrap 

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.