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
- Variables
- func ActivateableEips() []string
- func ActivePrecompiles(rules params.Rules) []common.Address
- func BlockHashOp(evm *EVM, block *big.Int) common.Hash
- func EnableEIP(eipNum int, jt *JumpTable) error
- func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64, ...) (ret []byte, remainingGas uint64, err error)
- func ValidEip(eipNum int) bool
- func WasmAccountTouchCost(cfg *params.ChainConfig, db StateDB, addr common.Address, withCode bool) uint64
- func WasmCallCost(db StateDB, contract common.Address, value *uint256.Int, budget uint64) (uint64, error)
- func WasmStateLoadCost(db StateDB, program common.Address, key common.Hash) uint64
- func WasmStateStoreCost(db StateDB, program common.Address, key, value common.Hash) uint64
- type AccountRef
- type AdvancedPrecompile
- type AdvancedPrecompileCall
- type BlockContext
- type CallContext
- type CanTransferFunc
- type Config
- type Contract
- func (c *Contract) Address() common.Address
- func (c *Contract) AsDelegate() *Contract
- func (c *Contract) BurnGas(amount uint64) error
- func (c *Contract) Caller() common.Address
- func (c *Contract) GetOp(n uint64) OpCode
- func (c *Contract) IsDelegateOrCallcode() bool
- func (c *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte)
- func (c *Contract) SetCodeOptionalHash(addr *common.Address, codeAndHash *codeAndHash)
- func (c *Contract) UseGas(gas uint64) (ok bool)
- func (c *Contract) Value() *uint256.Int
- type ContractRef
- type DefaultTxProcessor
- func (p DefaultTxProcessor) DropTip() bool
- func (p DefaultTxProcessor) EndTxHook(totalGasUsed uint64, evmSuccess bool)
- func (p DefaultTxProcessor) ExecuteWASM(scope *ScopeContext, input []byte, interpreter *EVMInterpreter) ([]byte, error)
- func (p DefaultTxProcessor) FillReceiptInfo(*types.Receipt)
- func (p DefaultTxProcessor) ForceRefundGas() uint64
- func (p DefaultTxProcessor) GasChargingHook(gasRemaining *uint64) (common.Address, error)
- func (p DefaultTxProcessor) GasPriceOp(evm *EVM) *big.Int
- func (p DefaultTxProcessor) L1BlockHash(blockCtx BlockContext, l1BlocKNumber uint64) (common.Hash, error)
- func (p DefaultTxProcessor) L1BlockNumber(blockCtx BlockContext) (uint64, error)
- func (p DefaultTxProcessor) MsgIsNonMutating() bool
- func (p DefaultTxProcessor) NonrefundableGas() uint64
- func (p DefaultTxProcessor) PopContract()
- func (p DefaultTxProcessor) PushContract(contract *Contract)
- func (p DefaultTxProcessor) ScheduledTxes() types.Transactions
- func (p DefaultTxProcessor) StartTxHook() (bool, uint64, error, []byte)
- type EVM
- func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, ...) (ret []byte, leftOverGas uint64, err error)
- func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, gas uint64, ...) (ret []byte, leftOverGas uint64, err error)
- func (evm *EVM) Cancel()
- func (evm *EVM) Cancelled() bool
- func (evm *EVM) ChainConfig() *params.ChainConfig
- func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)
- func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *uint256.Int, ...) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)
- func (evm *EVM) DecrementDepth()
- func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error)
- func (evm *EVM) Depth() int
- func (evm *EVM) IncrementDepth()
- func (evm *EVM) Interpreter() *EVMInterpreter
- func (evm *EVM) Reset(txCtx TxContext, statedb StateDB)
- func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error)
- type EVMInterpreter
- func (in *EVMInterpreter) Config() *Config
- func (in *EVMInterpreter) Depth() int
- func (in *EVMInterpreter) Evm() *EVM
- func (in *EVMInterpreter) GetReturnData() []byte
- func (in *EVMInterpreter) ReadOnly() bool
- func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error)
- func (in *EVMInterpreter) SetReturnData(data []byte)
- type EVMLogger
- type ErrInvalidOpCode
- type ErrStackOverflow
- type ErrStackUnderflow
- type GetHashFunc
- type JumpTable
- type Memory
- func (m *Memory) Copy(dst, src, len uint64)
- func (m *Memory) Data() []byte
- func (m *Memory) GetCopy(offset, size int64) (cpy []byte)
- func (m *Memory) GetPtr(offset, size int64) []byte
- func (m *Memory) Len() int
- func (m *Memory) Resize(size uint64)
- func (m *Memory) Set(offset, size uint64, value []byte)
- func (m *Memory) Set32(offset uint64, val *uint256.Int)
- type OpCode
- type PrecompiledContract
- type ScopeContext
- type Stack
- type StateDB
- type TransferFunc
- type TxContext
- type TxProcessingHook
Constants ¶
const ( GasQuickStep uint64 = 2 GasFastestStep uint64 = 3 GasFastStep uint64 = 5 GasMidStep uint64 = 8 GasSlowStep uint64 = 10 GasExtStep uint64 = 20 )
Gas costs
const ( DUP1 = 0x80 + iota DUP2 DUP3 DUP4 DUP5 DUP6 DUP7 DUP8 DUP9 DUP10 DUP11 DUP12 DUP13 DUP14 DUP15 DUP16 )
0x80 range - dups.
const ( SWAP1 = 0x90 + iota SWAP2 SWAP3 SWAP4 SWAP5 SWAP6 SWAP7 SWAP8 SWAP9 SWAP10 SWAP11 SWAP12 SWAP13 SWAP14 SWAP15 SWAP16 )
0x90 range - swaps.
Variables ¶
var ( PrecompiledAddressesCancun []common.Address PrecompiledAddressesBerlin []common.Address PrecompiledAddressesIstanbul []common.Address PrecompiledAddressesByzantium []common.Address PrecompiledAddressesHomestead []common.Address )
var ( PrecompiledContractsArbitrum = make(map[common.Address]PrecompiledContract) PrecompiledAddressesArbitrum []common.Address PrecompiledContractsArbOS30 = make(map[common.Address]PrecompiledContract) PrecompiledAddressesArbOS30 []common.Address )
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") ErrMaxInitCodeSizeExceeded = errors.New("max initcode size exceeded") ErrMaxCodeSizeExceeded = errors.New("max code 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
var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{10}): &bls12381G1Add{}, common.BytesToAddress([]byte{11}): &bls12381G1Mul{}, common.BytesToAddress([]byte{12}): &bls12381G1MultiExp{}, common.BytesToAddress([]byte{13}): &bls12381G2Add{}, common.BytesToAddress([]byte{14}): &bls12381G2Mul{}, common.BytesToAddress([]byte{15}): &bls12381G2MultiExp{}, common.BytesToAddress([]byte{16}): &bls12381Pairing{}, common.BytesToAddress([]byte{17}): &bls12381MapG1{}, common.BytesToAddress([]byte{18}): &bls12381MapG2{}, }
PrecompiledContractsBLS contains the set of pre-compiled Ethereum contracts specified in EIP-2537. These are exported for testing purposes.
var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{1}): &ecrecover{}, common.BytesToAddress([]byte{2}): &sha256hash{}, common.BytesToAddress([]byte{3}): &ripemd160hash{}, common.BytesToAddress([]byte{4}): &dataCopy{}, common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, common.BytesToAddress([]byte{9}): &blake2F{}, }
PrecompiledContractsBerlin contains the default set of pre-compiled Ethereum contracts used in the Berlin release.
var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{1}): &ecrecover{}, common.BytesToAddress([]byte{2}): &sha256hash{}, common.BytesToAddress([]byte{3}): &ripemd160hash{}, common.BytesToAddress([]byte{4}): &dataCopy{}, common.BytesToAddress([]byte{5}): &bigModExp{eip2565: false}, common.BytesToAddress([]byte{6}): &bn256AddByzantium{}, common.BytesToAddress([]byte{7}): &bn256ScalarMulByzantium{}, common.BytesToAddress([]byte{8}): &bn256PairingByzantium{}, }
PrecompiledContractsByzantium contains the default set of pre-compiled Ethereum contracts used in the Byzantium release.
var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{1}): &ecrecover{}, common.BytesToAddress([]byte{2}): &sha256hash{}, common.BytesToAddress([]byte{3}): &ripemd160hash{}, common.BytesToAddress([]byte{4}): &dataCopy{}, common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, common.BytesToAddress([]byte{9}): &blake2F{}, common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{}, }
PrecompiledContractsCancun contains the default set of pre-compiled Ethereum contracts used in the Cancun release.
var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{1}): &ecrecover{}, common.BytesToAddress([]byte{2}): &sha256hash{}, common.BytesToAddress([]byte{3}): &ripemd160hash{}, common.BytesToAddress([]byte{4}): &dataCopy{}, }
PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum contracts used in the Frontier and Homestead releases.
var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{1}): &ecrecover{}, common.BytesToAddress([]byte{2}): &sha256hash{}, common.BytesToAddress([]byte{3}): &ripemd160hash{}, common.BytesToAddress([]byte{4}): &dataCopy{}, common.BytesToAddress([]byte{5}): &bigModExp{eip2565: false}, common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, common.BytesToAddress([]byte{9}): &blake2F{}, }
PrecompiledContractsIstanbul contains the default set of pre-compiled Ethereum contracts used in the Istanbul release.
var PrecompiledContractsP256Verify = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, }
PrecompiledContractsP256Verify contains the precompiled Ethereum contract specified in EIP-7212.
Functions ¶
func ActivateableEips ¶
func ActivateableEips() []string
func ActivePrecompiles ¶
ActivePrecompiles returns the precompiles enabled with the current configuration.
func BlockHashOp ¶
adaptation of opBlockHash that doesn't require an EVM stack
func EnableEIP ¶
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 RunPrecompiledContract ¶
func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64, advancedInfo *AdvancedPrecompileCall) (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 WasmAccountTouchCost ¶
func WasmAccountTouchCost(cfg *params.ChainConfig, db StateDB, addr common.Address, withCode bool) uint64
Computes the cost of touching an account in wasm Note: the code here is adapted from gasEip2929AccountCheck with the most recent parameters as of The Merge
func WasmCallCost ¶
func WasmCallCost(db StateDB, contract common.Address, value *uint256.Int, budget uint64) (uint64, error)
Computes the cost of starting a call from wasm
The code here is adapted from the following functions with the most recent parameters as of The Merge
- operations_acl.go makeCallVariantGasCallEIP2929()
- gas_table.go gasCall()
func WasmStateLoadCost ¶
Computes the cost of doing a state load in wasm Note: the code here is adapted from gasSLoadEIP2929
func WasmStateStoreCost ¶
Computes the cost of doing a state store in wasm Note: the code here is adapted from makeGasSStoreFunc with the most recent parameters as of The Merge Note: the sentry check must be done by the caller
Types ¶
type AccountRef ¶
AccountRef implements ContractRef.
Account references are used during EVM initialisation and its primary use is to fetch addresses. Removing this object proves difficult because of the cached jump destinations which are fetched from the parent contract (i.e. the caller), which is a ContractRef.
func (AccountRef) Address ¶
func (ar AccountRef) Address() common.Address
Address casts AccountRef to an Address
type AdvancedPrecompile ¶
type AdvancedPrecompile interface { RunAdvanced(input []byte, suppliedGas uint64, advancedInfo *AdvancedPrecompileCall) (ret []byte, remainingGas uint64, err error) PrecompiledContract }
type AdvancedPrecompileCall ¶
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 // Arbitrum information ArbOSVersion uint64 BaseFeeInBlock *big.Int // Copy of BaseFee to be used in arbitrum's geth hooks and precompiles when BaseFee is lowered to 0 when vm runs with NoBaseFee flag and 0 gas price. Is nil when BaseFee isn't lowered to 0 }
BlockContext provides the EVM with auxiliary information. Once provided it shouldn't be modified.
type CallContext ¶
type CallContext interface { // Call calls another contract. Call(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error) // CallCode takes another contracts code and execute within our own context CallCode(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error) // DelegateCall is same as CallCode except sender and value is propagated from parent to child scope DelegateCall(env *EVM, me ContractRef, addr common.Address, data []byte, gas *big.Int) ([]byte, error) // Create creates a new contract Create(env *EVM, me ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error) }
CallContext provides a basic interface for the EVM calling conventions. The EVM depends on this context being implemented for doing subcalls and initialising new EVM contracts.
type CanTransferFunc ¶
CanTransferFunc is the signature of a transfer guard function
type Config ¶
type Config struct { Tracer EVMLogger // Opcode logger 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 ¶
type Contract struct { // CallerAddress is the result of the caller which initialised this // contract. However when the "call method" is delegated this value // needs to be initialised to that of the caller's caller. CallerAddress common.Address Code []byte CodeHash common.Hash CodeAddr *common.Address Input []byte 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 ContractRef, object ContractRef, value *uint256.Int, gas uint64) *Contract
NewContract returns a new contract environment for the execution of EVM.
func (*Contract) AsDelegate ¶
AsDelegate sets the contract to be a delegate call and returns the current contract (for chaining calls)
func (*Contract) Caller ¶
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) IsDelegateOrCallcode ¶
func (*Contract) SetCallCode ¶
SetCallCode sets the code of the contract and address of the backing data object
func (*Contract) SetCodeOptionalHash ¶
SetCodeOptionalHash can be used to provide code, but it's optional to provide hash. In case hash is not provided, the jumpdest analysis will not be saved to the parent context
type ContractRef ¶
ContractRef is a reference to the contract's backing object
type DefaultTxProcessor ¶
type DefaultTxProcessor struct {
// contains filtered or unexported fields
}
func (DefaultTxProcessor) DropTip ¶
func (p DefaultTxProcessor) DropTip() bool
func (DefaultTxProcessor) EndTxHook ¶
func (p DefaultTxProcessor) EndTxHook(totalGasUsed uint64, evmSuccess bool)
func (DefaultTxProcessor) ExecuteWASM ¶
func (p DefaultTxProcessor) ExecuteWASM(scope *ScopeContext, input []byte, interpreter *EVMInterpreter) ([]byte, error)
func (DefaultTxProcessor) FillReceiptInfo ¶
func (p DefaultTxProcessor) FillReceiptInfo(*types.Receipt)
func (DefaultTxProcessor) ForceRefundGas ¶
func (p DefaultTxProcessor) ForceRefundGas() uint64
func (DefaultTxProcessor) GasChargingHook ¶
func (p DefaultTxProcessor) GasChargingHook(gasRemaining *uint64) (common.Address, error)
func (DefaultTxProcessor) GasPriceOp ¶
func (p DefaultTxProcessor) GasPriceOp(evm *EVM) *big.Int
func (DefaultTxProcessor) L1BlockHash ¶
func (p DefaultTxProcessor) L1BlockHash(blockCtx BlockContext, l1BlocKNumber uint64) (common.Hash, error)
func (DefaultTxProcessor) L1BlockNumber ¶
func (p DefaultTxProcessor) L1BlockNumber(blockCtx BlockContext) (uint64, error)
func (DefaultTxProcessor) MsgIsNonMutating ¶
func (p DefaultTxProcessor) MsgIsNonMutating() bool
func (DefaultTxProcessor) NonrefundableGas ¶
func (p DefaultTxProcessor) NonrefundableGas() uint64
func (DefaultTxProcessor) PopContract ¶
func (p DefaultTxProcessor) PopContract()
func (DefaultTxProcessor) PushContract ¶
func (p DefaultTxProcessor) PushContract(contract *Contract)
func (DefaultTxProcessor) ScheduledTxes ¶
func (p DefaultTxProcessor) ScheduledTxes() types.Transactions
func (DefaultTxProcessor) StartTxHook ¶
func (p DefaultTxProcessor) StartTxHook() (bool, uint64, error, []byte)
type EVM ¶
type EVM struct { ProcessingHook TxProcessingHook // 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, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM
NewEVM returns a new EVM. The returned EVM is not thread safe and should only ever be used *once*.
func (*EVM) Call ¶
func (evm *EVM) Call(caller ContractRef, 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 takes 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 ContractRef, 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) ChainConfig ¶
func (evm *EVM) ChainConfig() *params.ChainConfig
ChainConfig returns the environment's chain configuration
func (*EVM) Create ¶
func (evm *EVM) Create(caller ContractRef, 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 ContractRef, 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) DecrementDepth ¶
func (evm *EVM) DecrementDepth()
func (*EVM) DelegateCall ¶
func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (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) IncrementDepth ¶
func (evm *EVM) IncrementDepth()
func (*EVM) Interpreter ¶
func (evm *EVM) Interpreter() *EVMInterpreter
Interpreter returns the current interpreter
func (*EVM) Reset ¶
Reset resets the EVM with a new transaction context.Reset This is not threadsafe and should only be done very cautiously.
func (*EVM) StaticCall ¶
func (evm *EVM) StaticCall(caller ContractRef, 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) Config ¶
func (in *EVMInterpreter) Config() *Config
func (*EVMInterpreter) Depth ¶
func (in *EVMInterpreter) Depth() int
func (*EVMInterpreter) Evm ¶
func (in *EVMInterpreter) Evm() *EVM
func (*EVMInterpreter) GetReturnData ¶
func (in *EVMInterpreter) GetReturnData() []byte
func (*EVMInterpreter) ReadOnly ¶
func (in *EVMInterpreter) ReadOnly() bool
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.
func (*EVMInterpreter) SetReturnData ¶
func (in *EVMInterpreter) SetReturnData(data []byte)
type EVMLogger ¶
type EVMLogger interface { // Arbitrum: capture a transfer, mint, or burn that happens outside of EVM execution CaptureArbitrumTransfer(env *EVM, from, to *common.Address, value *big.Int, before bool, purpose string) CaptureArbitrumStorageGet(key common.Hash, depth int, before bool) CaptureArbitrumStorageSet(key, value common.Hash, depth int, before bool) // Stylus: capture hostio invocation CaptureStylusHostio(name string, args, outs []byte, startInk, endInk uint64) // Transaction level CaptureTxStart(gasLimit uint64) CaptureTxEnd(restGas uint64) // Top call frame CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) CaptureEnd(output []byte, gasUsed uint64, err error) // Rest of call frames CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) CaptureExit(output []byte, gasUsed uint64, err error) // Opcode level CaptureState(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, rData []byte, depth int, err error) CaptureFault(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, depth int, err error) }
EVMLogger is used to collect execution traces from an EVM transaction execution. CaptureState is called for each step of the VM with the current VM state. Note that reference types are actual VM data structures; make copies if you need to retain them beyond the current call.
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
type ErrStackUnderflow ¶
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 ¶
func (e *ErrStackUnderflow) Error() string
type GetHashFunc ¶
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.
type Memory ¶
type Memory struct {
// contains filtered or unexported fields
}
Memory implements a simple memory model for the ethereum virtual machine.
func (*Memory) Copy ¶
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.
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 ( CREATE OpCode = 0xf0 CALL OpCode = 0xf1 CALLCODE OpCode = 0xf2 RETURN OpCode = 0xf3 DELEGATECALL OpCode = 0xf4 CREATE2 OpCode = 0xf5 STATICCALL OpCode = 0xfa REVERT OpCode = 0xfd INVALID OpCode = 0xfe SELFDESTRUCT OpCode = 0xff )
0xf0 range - closures.
const (
KECCAK256 OpCode = 0x20
)
0x20 range - crypto.
func StringToOp ¶
StringToOp finds the opcode whose name is stored in `str`.
type PrecompiledContract ¶
type PrecompiledContract interface { RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use Run(input []byte) ([]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 ScopeContext ¶
ScopeContext contains the things that are per-call, such as stack and memory, but not transients like pc and gas
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 initialised objects.
type StateDB ¶
type StateDB interface { // Arbitrum: manage Stylus wasms ActivateWasm(moduleHash common.Hash, asm, module []byte) TryGetActivatedAsm(moduleHash common.Hash) (asm []byte, err error) GetActivatedModule(moduleHash common.Hash) (module []byte) RecordCacheWasm(wasm state.CacheWasm) RecordEvictWasm(wasm state.EvictWasm) GetRecentWasms() state.RecentWasms // Arbitrum: track stylus's memory footprint GetStylusPages() (uint16, uint16) GetStylusPagesOpen() uint16 SetStylusPagesOpen(open uint16) AddStylusPages(new uint16) (uint16, uint16) AddStylusPagesEver(new uint16) Deterministic() bool Database() state.Database CreateAccount(common.Address) SubBalance(common.Address, *uint256.Int) AddBalance(common.Address, *uint256.Int) GetBalance(common.Address) *uint256.Int ExpectBalanceBurn(*big.Int) GetNonce(common.Address) uint64 SetNonce(common.Address, uint64) GetCodeHash(common.Address) common.Hash GetCode(common.Address) []byte SetCode(common.Address, []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) GetTransientState(addr common.Address, key common.Hash) common.Hash SetTransientState(addr common.Address, key, value common.Hash) SelfDestruct(common.Address) HasSelfDestructed(common.Address) bool GetSelfDestructs() []common.Address Selfdestruct6780(common.Address) // 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) 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) GetCurrentTxLogs() []*types.Log }
StateDB is an EVM database for full state querying.
type TransferFunc ¶
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 }
TxContext provides the EVM with information about a transaction. All fields can change between transactions.
type TxProcessingHook ¶
type TxProcessingHook interface { StartTxHook() (bool, uint64, error, []byte) // return 4-tuple rather than *struct to avoid an import cycle GasChargingHook(gasRemaining *uint64) (common.Address, error) PushContract(contract *Contract) PopContract() ForceRefundGas() uint64 NonrefundableGas() uint64 DropTip() bool EndTxHook(totalGasUsed uint64, evmSuccess bool) ScheduledTxes() types.Transactions L1BlockNumber(blockCtx BlockContext) (uint64, error) L1BlockHash(blockCtx BlockContext, l1BlocKNumber uint64) (common.Hash, error) GasPriceOp(evm *EVM) *big.Int FillReceiptInfo(receipt *types.Receipt) MsgIsNonMutating() bool ExecuteWASM(scope *ScopeContext, input []byte, interpreter *EVMInterpreter) ([]byte, error) }
Source Files ¶
- analysis.go
- common.go
- contract.go
- contract_arbitrum.go
- contracts.go
- contracts_arbitrum.go
- doc.go
- eips.go
- errors.go
- evm.go
- evm_arbitrum.go
- gas.go
- gas_table.go
- instructions.go
- instructions_arbitrum.go
- interface.go
- interpreter.go
- interpreter_arbitrum.go
- jump_table.go
- jump_table_export.go
- logger.go
- memory.go
- memory_table.go
- opcodes.go
- operations_acl.go
- operations_acl_arbitrum.go
- stack.go
- stack_arbitrum.go
- stack_table.go