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 (
    	GasQuickStep   uint64 = 2
    	GasFastestStep uint64 = 3
    	GasFastStep    uint64 = 5
    	GasMidStep     uint64 = 8
    	GasSlowStep    uint64 = 10
    	GasExtStep     uint64 = 20
    )

      Gas costs

      Variables

      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")
      	ErrTraceLimitReached        = errors.New("the number of logs reached the specified limit")
      	ErrInsufficientBalance      = errors.New("insufficient balance for transfer")
      	ErrContractAddressCollision = errors.New("contract address collision")
      	ErrNoCompatibleInterpreter  = errors.New("no compatible interpreter")
      )

        List execution errors

        View Source
        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{},
        	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.

          View Source
          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.

            View Source
            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{},
            	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.

              Functions

              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 RunPrecompiledContract

                func RunPrecompiledContract(p PrecompiledContract, input []byte, contract *Contract) (ret []byte, err error)

                  RunPrecompiledContract runs and evaluates the output of a precompiled contract.

                  func WriteLogs

                  func WriteLogs(writer io.Writer, logs []*types.Log)

                    WriteLogs writes vm logs in a readable format to the given writer

                    func WriteTrace

                    func WriteTrace(writer io.Writer, logs []StructLog)

                      WriteTrace writes a formatted trace to the given writer

                      Types

                      type AccountRef

                      type AccountRef common.Address

                        AccountRef implements ContractRef.

                        Account references are used during EVM initialisation and it's 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 a Address

                          type CallContext

                          type CallContext interface {
                          	// Call another contract
                          	Call(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)
                          	// Take another's contract code and execute within our own context
                          	CallCode(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)
                          	// 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 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

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

                              CanTransferFunc is the signature of a transfer guard function

                              type Config

                              type Config struct {
                              	Debug                   bool   // Enables debugging
                              	Tracer                  Tracer // Opcode logger
                              	NoRecursion             bool   // Disables call, callcode, delegate call and create
                              	EnablePreimageRecording bool   // Enables recording of SHA3/keccak preimages
                              
                              	JumpTable [256]operation // EVM instruction table, automatically populated if unset
                              
                              	EWASMInterpreter string // External EWASM interpreter options
                              	EVMInterpreter   string // External EVM interpreter options
                              
                              	ExtraEips []int // Additional EIPS that are to be enabled
                              }

                                Config are the configuration options for the Interpreter

                                type Context

                                type Context 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
                                
                                	// Message information
                                	Origin   common.Address // Provides information for ORIGIN
                                	GasPrice *big.Int       // Provides information for GASPRICE
                                
                                	// Block information
                                	Coinbase    common.Address // Provides information for COINBASE
                                	GasLimit    uint64         // Provides information for GASLIMIT
                                	BlockNumber *big.Int       // Provides information for NUMBER
                                	Time        *big.Int       // Provides information for TIME
                                	Difficulty  *big.Int       // Provides information for DIFFICULTY
                                }

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

                                  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 *big.Int, gas uint64) *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) AsDelegate

                                        func (c *Contract) AsDelegate() *Contract

                                          AsDelegate sets the contract to be a delegate call and returns the current contract (for chaining calls)

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

                                            func (c *Contract) GetByte(n uint64) byte

                                              GetByte returns the n'th byte in the contract's byte array

                                              func (*Contract) GetOp

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

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

                                                func (*Contract) SetCallCode

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

                                                  SetCallCode sets the code of the contract and address of the backing data object

                                                  func (*Contract) SetCodeOptionalHash

                                                  func (c *Contract) SetCodeOptionalHash(addr *common.Address, codeAndHash *codeAndHash)

                                                    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

                                                    func (*Contract) UseGas

                                                    func (c *Contract) UseGas(gas uint64) (ok bool)

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

                                                      func (*Contract) Value

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

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

                                                        type ContractRef

                                                        type ContractRef interface {
                                                        	Address() common.Address
                                                        }

                                                          ContractRef is a reference to the contract's backing object

                                                          type EVM

                                                          type EVM struct {
                                                          	// Context provides auxiliary blockchain related information
                                                          	Context
                                                          	// StateDB gives access to the underlying state
                                                          	StateDB StateDB
                                                          	// 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(ctx Context, statedb StateDB, chainConfig *params.ChainConfig, vmConfig 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 *big.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 *big.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 ContractRef, code []byte, gas uint64, value *big.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 *big.Int, salt *big.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 sha3(0xff ++ msg.sender ++ salt ++ sha3(init_code))[12:] instead of the usual sender-and-nonce-hash as the address where the contract is initialized at.

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

                                                                              func (evm *EVM) Interpreter() Interpreter

                                                                                Interpreter returns the current interpreter

                                                                                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, cfg Config) *EVMInterpreter

                                                                                      NewEVMInterpreter returns a new instance of the Interpreter.

                                                                                      func (*EVMInterpreter) CanRun

                                                                                      func (in *EVMInterpreter) CanRun(code []byte) bool

                                                                                        CanRun tells if the contract, passed as an argument, can be run by the current 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 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 Interpreter

                                                                                            type Interpreter interface {
                                                                                            	// 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.
                                                                                            	Run(contract *Contract, input []byte, static bool) ([]byte, error)
                                                                                            	// CanRun tells if the contract, passed as an argument, can be
                                                                                            	// run by the current interpreter. This is meant so that the
                                                                                            	// caller can do something like:
                                                                                            	//
                                                                                            	// “`golang
                                                                                            	// for _, interpreter := range interpreters {
                                                                                            	//   if interpreter.CanRun(contract.code) {
                                                                                            	//     interpreter.Run(contract.code, input)
                                                                                            	//   }
                                                                                            	// }
                                                                                            	// “`
                                                                                            	CanRun([]byte) bool
                                                                                            }

                                                                                              Interpreter is used to run Ethereum based contracts and will utilise the passed environment to query external sources for state information. The Interpreter will run the byte code VM based on the passed configuration.

                                                                                              type JSONLogger

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

                                                                                              func NewJSONLogger

                                                                                              func NewJSONLogger(cfg *LogConfig, writer io.Writer) *JSONLogger

                                                                                                NewJSONLogger creates a new EVM tracer that prints execution steps as JSON objects into the provided stream.

                                                                                                func (*JSONLogger) CaptureEnd

                                                                                                func (l *JSONLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error

                                                                                                  CaptureEnd is triggered at end of execution.

                                                                                                  func (*JSONLogger) CaptureFault

                                                                                                  func (l *JSONLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error

                                                                                                    CaptureFault outputs state information on the logger.

                                                                                                    func (*JSONLogger) CaptureStart

                                                                                                    func (l *JSONLogger) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error

                                                                                                    func (*JSONLogger) CaptureState

                                                                                                    func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error

                                                                                                      CaptureState outputs state information on the logger.

                                                                                                      type JumpTable

                                                                                                      type JumpTable [256]operation

                                                                                                        JumpTable contains the EVM opcodes supported at a given fork.

                                                                                                        type LogConfig

                                                                                                        type LogConfig struct {
                                                                                                        	DisableMemory  bool // disable memory capture
                                                                                                        	DisableStack   bool // disable stack capture
                                                                                                        	DisableStorage bool // disable storage capture
                                                                                                        	Debug          bool // print output during capture end
                                                                                                        	Limit          int  // maximum length of output, but zero means unlimited
                                                                                                        }

                                                                                                          LogConfig are the configuration options for structured logger the EVM

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

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

                                                                                                                Data returns the backing slice

                                                                                                                func (*Memory) GetCopy

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

                                                                                                                  Get returns offset + size as a new slice

                                                                                                                  func (*Memory) GetPtr

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

                                                                                                                    GetPtr returns the offset + size

                                                                                                                    func (*Memory) Len

                                                                                                                    func (m *Memory) Len() int

                                                                                                                      Len returns the length of the backing slice

                                                                                                                      func (*Memory) Print

                                                                                                                      func (m *Memory) Print()

                                                                                                                        Print dumps the content of the memory.

                                                                                                                        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 *big.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 = iota
                                                                                                                                	ADD
                                                                                                                                	MUL
                                                                                                                                	SUB
                                                                                                                                	DIV
                                                                                                                                	SDIV
                                                                                                                                	MOD
                                                                                                                                	SMOD
                                                                                                                                	ADDMOD
                                                                                                                                	MULMOD
                                                                                                                                	EXP
                                                                                                                                	SIGNEXTEND
                                                                                                                                )

                                                                                                                                  0x0 range - arithmetic ops.

                                                                                                                                  const (
                                                                                                                                  	LT OpCode = iota + 0x10
                                                                                                                                  	GT
                                                                                                                                  	SLT
                                                                                                                                  	SGT
                                                                                                                                  	EQ
                                                                                                                                  	ISZERO
                                                                                                                                  	AND
                                                                                                                                  	OR
                                                                                                                                  	XOR
                                                                                                                                  	NOT
                                                                                                                                  	BYTE
                                                                                                                                  	SHL
                                                                                                                                  	SHR
                                                                                                                                  	SAR
                                                                                                                                  
                                                                                                                                  	SHA3 = 0x20
                                                                                                                                  )

                                                                                                                                    0x10 range - comparison ops.

                                                                                                                                    const (
                                                                                                                                    	ADDRESS OpCode = 0x30 + iota
                                                                                                                                    	BALANCE
                                                                                                                                    	ORIGIN
                                                                                                                                    	CALLER
                                                                                                                                    	CALLVALUE
                                                                                                                                    	CALLDATALOAD
                                                                                                                                    	CALLDATASIZE
                                                                                                                                    	CALLDATACOPY
                                                                                                                                    	CODESIZE
                                                                                                                                    	CODECOPY
                                                                                                                                    	GASPRICE
                                                                                                                                    	EXTCODESIZE
                                                                                                                                    	EXTCODECOPY
                                                                                                                                    	RETURNDATASIZE
                                                                                                                                    	RETURNDATACOPY
                                                                                                                                    	EXTCODEHASH
                                                                                                                                    )

                                                                                                                                      0x30 range - closure state.

                                                                                                                                      const (
                                                                                                                                      	BLOCKHASH OpCode = 0x40 + iota
                                                                                                                                      	COINBASE
                                                                                                                                      	TIMESTAMP
                                                                                                                                      	NUMBER
                                                                                                                                      	DIFFICULTY
                                                                                                                                      	GASLIMIT
                                                                                                                                      	CHAINID     = 0x46
                                                                                                                                      	SELFBALANCE = 0x47
                                                                                                                                      )

                                                                                                                                        0x40 range - block operations.

                                                                                                                                        const (
                                                                                                                                        	POP OpCode = 0x50 + iota
                                                                                                                                        	MLOAD
                                                                                                                                        	MSTORE
                                                                                                                                        	MSTORE8
                                                                                                                                        	SLOAD
                                                                                                                                        	SSTORE
                                                                                                                                        	JUMP
                                                                                                                                        	JUMPI
                                                                                                                                        	PC
                                                                                                                                        	MSIZE
                                                                                                                                        	GAS
                                                                                                                                        	JUMPDEST
                                                                                                                                        )

                                                                                                                                          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
                                                                                                                                          	DUP1
                                                                                                                                          	DUP2
                                                                                                                                          	DUP3
                                                                                                                                          	DUP4
                                                                                                                                          	DUP5
                                                                                                                                          	DUP6
                                                                                                                                          	DUP7
                                                                                                                                          	DUP8
                                                                                                                                          	DUP9
                                                                                                                                          	DUP10
                                                                                                                                          	DUP11
                                                                                                                                          	DUP12
                                                                                                                                          	DUP13
                                                                                                                                          	DUP14
                                                                                                                                          	DUP15
                                                                                                                                          	DUP16
                                                                                                                                          	SWAP1
                                                                                                                                          	SWAP2
                                                                                                                                          	SWAP3
                                                                                                                                          	SWAP4
                                                                                                                                          	SWAP5
                                                                                                                                          	SWAP6
                                                                                                                                          	SWAP7
                                                                                                                                          	SWAP8
                                                                                                                                          	SWAP9
                                                                                                                                          	SWAP10
                                                                                                                                          	SWAP11
                                                                                                                                          	SWAP12
                                                                                                                                          	SWAP13
                                                                                                                                          	SWAP14
                                                                                                                                          	SWAP15
                                                                                                                                          	SWAP16
                                                                                                                                          )

                                                                                                                                            0x60 range.

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

                                                                                                                                              0xa0 range - logging ops.

                                                                                                                                              const (
                                                                                                                                              	PUSH OpCode = 0xb0 + iota
                                                                                                                                              	DUP
                                                                                                                                              	SWAP
                                                                                                                                              )

                                                                                                                                                unofficial opcodes used for parsing.

                                                                                                                                                const (
                                                                                                                                                	CREATE OpCode = 0xf0 + iota
                                                                                                                                                	CALL
                                                                                                                                                	CALLCODE
                                                                                                                                                	RETURN
                                                                                                                                                	DELEGATECALL
                                                                                                                                                	CREATE2
                                                                                                                                                	STATICCALL = 0xfa
                                                                                                                                                
                                                                                                                                                	REVERT       = 0xfd
                                                                                                                                                	SELFDESTRUCT = 0xff
                                                                                                                                                )

                                                                                                                                                  0xf0 range - closures.

                                                                                                                                                  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.

                                                                                                                                                      func (OpCode) IsStaticJump

                                                                                                                                                      func (op OpCode) IsStaticJump() bool

                                                                                                                                                        IsStaticJump specifies if an opcode is JUMP.

                                                                                                                                                        func (OpCode) String

                                                                                                                                                        func (op OpCode) String() string

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

                                                                                                                                                            func (*Stack) Back

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

                                                                                                                                                              Back returns the n'th item in stack

                                                                                                                                                              func (*Stack) Data

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

                                                                                                                                                                Data returns the underlying big.Int array.

                                                                                                                                                                func (*Stack) Print

                                                                                                                                                                func (st *Stack) Print()

                                                                                                                                                                  Print dumps the content of the stack

                                                                                                                                                                  type StateDB

                                                                                                                                                                  type StateDB interface {
                                                                                                                                                                  	CreateAccount(common.Address)
                                                                                                                                                                  
                                                                                                                                                                  	SubBalance(common.Address, *big.Int)
                                                                                                                                                                  	AddBalance(common.Address, *big.Int)
                                                                                                                                                                  	GetBalance(common.Address) *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)
                                                                                                                                                                  
                                                                                                                                                                  	Suicide(common.Address) bool
                                                                                                                                                                  	HasSuicided(common.Address) bool
                                                                                                                                                                  
                                                                                                                                                                  	// Exist reports whether the given account exists in state.
                                                                                                                                                                  	// Notably this should also return true for suicided 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
                                                                                                                                                                  
                                                                                                                                                                  	RevertToSnapshot(int)
                                                                                                                                                                  	Snapshot() int
                                                                                                                                                                  
                                                                                                                                                                  	AddLog(*types.Log)
                                                                                                                                                                  	AddPreimage(common.Hash, []byte)
                                                                                                                                                                  
                                                                                                                                                                  	ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error
                                                                                                                                                                  }

                                                                                                                                                                    StateDB is an EVM database for full state querying.

                                                                                                                                                                    type Storage

                                                                                                                                                                    type Storage map[common.Hash]common.Hash

                                                                                                                                                                      Storage represents a contract's storage.

                                                                                                                                                                      func (Storage) Copy

                                                                                                                                                                      func (s Storage) Copy() Storage

                                                                                                                                                                        Copy duplicates the current storage.

                                                                                                                                                                        type StructLog

                                                                                                                                                                        type StructLog struct {
                                                                                                                                                                        	Pc            uint64                      `json:"pc"`
                                                                                                                                                                        	Op            OpCode                      `json:"op"`
                                                                                                                                                                        	Gas           uint64                      `json:"gas"`
                                                                                                                                                                        	GasCost       uint64                      `json:"gasCost"`
                                                                                                                                                                        	Memory        []byte                      `json:"memory"`
                                                                                                                                                                        	MemorySize    int                         `json:"memSize"`
                                                                                                                                                                        	Stack         []*big.Int                  `json:"stack"`
                                                                                                                                                                        	Storage       map[common.Hash]common.Hash `json:"-"`
                                                                                                                                                                        	Depth         int                         `json:"depth"`
                                                                                                                                                                        	RefundCounter uint64                      `json:"refund"`
                                                                                                                                                                        	Err           error                       `json:"-"`
                                                                                                                                                                        }

                                                                                                                                                                          StructLog is emitted to the EVM each cycle and lists information about the current internal state prior to the execution of the statement.

                                                                                                                                                                          func (*StructLog) ErrorString

                                                                                                                                                                          func (s *StructLog) ErrorString() string

                                                                                                                                                                            ErrorString formats the log's error as a string.

                                                                                                                                                                            func (StructLog) MarshalJSON

                                                                                                                                                                            func (s StructLog) MarshalJSON() ([]byte, error)

                                                                                                                                                                              MarshalJSON marshals as JSON.

                                                                                                                                                                              func (*StructLog) OpName

                                                                                                                                                                              func (s *StructLog) OpName() string

                                                                                                                                                                                OpName formats the operand name in a human-readable format.

                                                                                                                                                                                func (*StructLog) UnmarshalJSON

                                                                                                                                                                                func (s *StructLog) UnmarshalJSON(input []byte) error

                                                                                                                                                                                  UnmarshalJSON unmarshals from JSON.

                                                                                                                                                                                  type StructLogger

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

                                                                                                                                                                                    StructLogger is an EVM state logger and implements Tracer.

                                                                                                                                                                                    StructLogger can capture state based on the given Log configuration and also keeps a track record of modified storage which is used in reporting snapshots of the contract their storage.

                                                                                                                                                                                    func NewStructLogger

                                                                                                                                                                                    func NewStructLogger(cfg *LogConfig) *StructLogger

                                                                                                                                                                                      NewStructLogger returns a new logger

                                                                                                                                                                                      func (*StructLogger) CaptureEnd

                                                                                                                                                                                      func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error

                                                                                                                                                                                        CaptureEnd is called after the call finishes to finalize the tracing.

                                                                                                                                                                                        func (*StructLogger) CaptureFault

                                                                                                                                                                                        func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error

                                                                                                                                                                                          CaptureFault implements the Tracer interface to trace an execution fault while running an opcode.

                                                                                                                                                                                          func (*StructLogger) CaptureStart

                                                                                                                                                                                          func (l *StructLogger) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error

                                                                                                                                                                                            CaptureStart implements the Tracer interface to initialize the tracing operation.

                                                                                                                                                                                            func (*StructLogger) CaptureState

                                                                                                                                                                                            func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error

                                                                                                                                                                                              CaptureState logs a new structured log message and pushes it out to the environment

                                                                                                                                                                                              CaptureState also tracks SSTORE ops to track dirty values.

                                                                                                                                                                                              func (*StructLogger) Error

                                                                                                                                                                                              func (l *StructLogger) Error() error

                                                                                                                                                                                                Error returns the VM error captured by the trace.

                                                                                                                                                                                                func (*StructLogger) Output

                                                                                                                                                                                                func (l *StructLogger) Output() []byte

                                                                                                                                                                                                  Output returns the VM return value captured by the trace.

                                                                                                                                                                                                  func (*StructLogger) StructLogs

                                                                                                                                                                                                  func (l *StructLogger) StructLogs() []StructLog

                                                                                                                                                                                                    StructLogs returns the captured log entries.

                                                                                                                                                                                                    type Tracer

                                                                                                                                                                                                    type Tracer interface {
                                                                                                                                                                                                    	CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error
                                                                                                                                                                                                    	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
                                                                                                                                                                                                    	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
                                                                                                                                                                                                    	CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error
                                                                                                                                                                                                    }

                                                                                                                                                                                                      Tracer 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 TransferFunc

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

                                                                                                                                                                                                        TransferFunc is the signature of a transfer function

                                                                                                                                                                                                        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.