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

      View Source
      const (
      	ColdAccountAccessCostEIP2929 = uint64(2600) // COLD_ACCOUNT_ACCESS_COST
      	ColdSloadCostEIP2929         = uint64(2100) // COLD_SLOAD_COST
      	WarmStorageReadCostEIP2929   = uint64(100)  // WARM_STORAGE_READ_COST
      )

      Variables

      View Source
      var (
      	PrecompiledAddressesYoloV2    []common.Address
      	PrecompiledAddressesIstanbul  []common.Address
      	PrecompiledAddressesByzantium []common.Address
      	PrecompiledAddressesHomestead []common.Address
      )
      View Source
      var (
      	// ErrInvalidSubroutineEntry means that a BEGINSUB was reached via iteration,
      	// as opposed to from a JUMPSUB instruction
      	ErrInvalidSubroutineEntry   = errors.New("invalid subroutine entry")
      	ErrOutOfGas                 = errors.New("out of gas")
      	ErrCodeStoreOutOfGas        = errors.New("contract creation code storage out of gas")
      	ErrDepth                    = errors.New("max call depth exceeded")
      	ErrInsufficientBalance      = errors.New("insufficient balance for transfer")
      	ErrContractAddressCollision = errors.New("contract address collision")
      	ErrExecutionReverted        = errors.New("execution reverted")
      	ErrMaxCodeSizeExceeded      = errors.New("max code size exceeded")
      	ErrInvalidJump              = errors.New("invalid jump destination")
      	ErrWriteProtection          = errors.New("write protection")
      	ErrReturnDataOutOfBounds    = errors.New("return data out of bounds")
      	ErrGasUintOverflow          = errors.New("gas uint64 overflow")
      	ErrInvalidRetsub            = errors.New("invalid retsub")
      	ErrReturnStackExceeded      = errors.New("return stack limit reached")
      )

        List evm 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{eip2565: false},
        	common.BytesToAddress([]byte{6}): &bn256AddByzantium{},
        	common.BytesToAddress([]byte{7}): &bn256ScalarMulByzantium{},
        	common.BytesToAddress([]byte{8}): &bn256PairingByzantium{},
        }

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

          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{eip2565: false},
            	common.BytesToAddress([]byte{6}): &bn256AddIstanbul{},
            	common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{},
            	common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{},
            	common.BytesToAddress([]byte{9}): &blake2F{},
            }

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

              View Source
              var PrecompiledContractsYoloV2 = map[common.Address]PrecompiledContract{
              	common.BytesToAddress([]byte{1}):  &ecrecover{},
              	common.BytesToAddress([]byte{2}):  &sha256hash{},
              	common.BytesToAddress([]byte{3}):  &ripemd160hash{},
              	common.BytesToAddress([]byte{4}):  &dataCopy{},
              	common.BytesToAddress([]byte{5}):  &bigModExp{eip2565: false},
              	common.BytesToAddress([]byte{6}):  &bn256AddIstanbul{},
              	common.BytesToAddress([]byte{7}):  &bn256ScalarMulIstanbul{},
              	common.BytesToAddress([]byte{8}):  &bn256PairingIstanbul{},
              	common.BytesToAddress([]byte{9}):  &blake2F{},
              	common.BytesToAddress([]byte{10}): &bls12381G1Add{},
              	common.BytesToAddress([]byte{11}): &bls12381G1Mul{},
              	common.BytesToAddress([]byte{12}): &bls12381G1MultiExp{},
              	common.BytesToAddress([]byte{13}): &bls12381G2Add{},
              	common.BytesToAddress([]byte{14}): &bls12381G2Mul{},
              	common.BytesToAddress([]byte{15}): &bls12381G2MultiExp{},
              	common.BytesToAddress([]byte{16}): &bls12381Pairing{},
              	common.BytesToAddress([]byte{17}): &bls12381MapG1{},
              	common.BytesToAddress([]byte{18}): &bls12381MapG2{},
              }

                PrecompiledContractsYoloV2 contains the default set of pre-compiled Ethereum contracts used in the Yolo v2 test release.

                Functions

                func ActivateableEips

                func ActivateableEips() []string

                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 NewMarkdownLogger

                  func NewMarkdownLogger(cfg *LogConfig, writer io.Writer) *mdLogger

                    NewMarkdownLogger creates a logger which outputs information in a format adapted for human readability, and is also a valid markdown table

                    func RunPrecompiledContract

                    func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error)

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

                      func ValidEip

                      func ValidEip(eipNum int) bool

                      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 BlockContext

                              type BlockContext struct {
                              	// CanTransfer returns whether the account contains
                              	// sufficient ether to transfer the value
                              	CanTransfer CanTransferFunc
                              	// Transfer transfers ether from one account to the other
                              	Transfer TransferFunc
                              	// GetHash returns the hash corresponding to n
                              	GetHash GetHashFunc
                              
                              	// Block information
                              	Coinbase    common.Address // Provides information for COINBASE
                              	GasLimit    uint64         // Provides information for GASLIMIT
                              	BlockNumber *big.Int       // Provides information for NUMBER
                              	Time        *big.Int       // Provides information for TIME
                              	Difficulty  *big.Int       // Provides information for DIFFICULTY
                              }

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

                                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 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 BlockContext
                                                              	TxContext
                                                              	// 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(blockCtx BlockContext, txCtx TxContext, 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) ActivePrecompiles

                                                                  func (evm *EVM) ActivePrecompiles() []common.Address

                                                                    ActivePrecompiles returns the addresses of the precompiles enabled with the current configuration

                                                                    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 *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)

                                                                                  Create2 creates a new contract using code as deployment code.

                                                                                  The different between Create2 with Create is Create2 uses 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) Reset

                                                                                      func (evm *EVM) Reset(txCtx TxContext, statedb StateDB)

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

                                                                                        func (*EVM) StaticCall

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

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

                                                                                          type EVMInterpreter

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

                                                                                            EVMInterpreter represents an EVM interpreter

                                                                                            func NewEVMInterpreter

                                                                                            func NewEVMInterpreter(evm *EVM, 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 ErrInvalidOpCode

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

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

                                                                                                    func (*ErrInvalidOpCode) Error

                                                                                                    func (e *ErrInvalidOpCode) Error() string

                                                                                                    type ErrStackOverflow

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

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

                                                                                                      func (*ErrStackOverflow) Error

                                                                                                      func (e *ErrStackOverflow) Error() string

                                                                                                      type ErrStackUnderflow

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

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

                                                                                                        func (*ErrStackUnderflow) Error

                                                                                                        func (e *ErrStackUnderflow) Error() string

                                                                                                        type GetHashFunc

                                                                                                        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, rStack *ReturnStack, 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, rStack *ReturnStack, rData []byte, 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
                                                                                                                      	DisableReturnData bool // disable return data capture
                                                                                                                      	Debug             bool // print output during capture end
                                                                                                                      	Limit             int  // maximum length of output, but zero means unlimited
                                                                                                                      	// Chain overrides, can be used to execute a trace using future fork rules
                                                                                                                      	Overrides *params.ChainConfig `json:"overrides,omitempty"`
                                                                                                                      }

                                                                                                                        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 *uint256.Int)

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

                                                                                                                                            type OpCode

                                                                                                                                            type OpCode byte

                                                                                                                                              OpCode is an EVM opcode

                                                                                                                                              const (
                                                                                                                                              	STOP OpCode = 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 OpCode = 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     OpCode = 0x46
                                                                                                                                                    	SELFBALANCE OpCode = 0x47
                                                                                                                                                    )

                                                                                                                                                      0x40 range - block operations.

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

                                                                                                                                                        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   OpCode = 0xfa
                                                                                                                                                              	REVERT       OpCode = 0xfd
                                                                                                                                                              	SELFDESTRUCT OpCode = 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 ReturnStack

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

                                                                                                                                                                          ReturnStack is an object for basic return stack operations.

                                                                                                                                                                          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) *uint256.Int

                                                                                                                                                                              Back returns the n'th item in stack

                                                                                                                                                                              func (*Stack) Data

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

                                                                                                                                                                                Data returns the underlying uint256.Int array.

                                                                                                                                                                                func (*Stack) 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
                                                                                                                                                                                  
                                                                                                                                                                                  	AddressInAccessList(addr common.Address) bool
                                                                                                                                                                                  	SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)
                                                                                                                                                                                  	// AddAddressToAccessList adds the given address to the access list. This operation is safe to perform
                                                                                                                                                                                  	// even if the feature/fork is not active yet
                                                                                                                                                                                  	AddAddressToAccessList(addr common.Address)
                                                                                                                                                                                  	// AddSlotToAccessList adds the given (address,slot) to the access list. This operation is safe to perform
                                                                                                                                                                                  	// even if the feature/fork is not active yet
                                                                                                                                                                                  	AddSlotToAccessList(addr common.Address, slot common.Hash)
                                                                                                                                                                                  
                                                                                                                                                                                  	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"`
                                                                                                                                                                                        	ReturnStack   []uint32                    `json:"returnStack"`
                                                                                                                                                                                        	ReturnData    []byte                      `json:"returnData"`
                                                                                                                                                                                        	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, rStack *ReturnStack, 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, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error

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

                                                                                                                                                                                                              CaptureState also tracks SLOAD/SSTORE ops to track storage change.

                                                                                                                                                                                                              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, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error
                                                                                                                                                                                                                    	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, 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

                                                                                                                                                                                                                        type TxContext

                                                                                                                                                                                                                        type TxContext struct {
                                                                                                                                                                                                                        	// Message information
                                                                                                                                                                                                                        	Origin   common.Address // Provides information for ORIGIN
                                                                                                                                                                                                                        	GasPrice *big.Int       // Provides information for GASPRICE
                                                                                                                                                                                                                        }

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

                                                                                                                                                                                                                          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.