go-ethereum: github.com/ethereum/go-ethereum/core/vm Index | Files | Directories

package vm

import "github.com/ethereum/go-ethereum/core/vm"

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

Package Files

analysis.go common.go contract.go contracts.go doc.go eips.go errors.go evm.go gas.go gas_table.go gen_structlog.go instructions.go int_pool_verifier_empty.go interface.go interpreter.go intpool.go jump_table.go logger.go logger_json.go memory.go memory_table.go opcodes.go stack.go stack_table.go

Constants

const (
    GasQuickStep   uint64 = 2
    GasFastestStep uint64 = 3
    GasFastStep    uint64 = 5
    GasMidStep     uint64 = 8
    GasSlowStep    uint64 = 10
    GasExtStep     uint64 = 20
)

Gas costs

Variables

var (
    ErrOutOfGas                 = errors.New("out of gas")
    ErrCodeStoreOutOfGas        = errors.New("contract creation code storage out of gas")
    ErrDepth                    = errors.New("max call depth exceeded")
    ErrTraceLimitReached        = errors.New("the number of logs reached the specified limit")
    ErrInsufficientBalance      = errors.New("insufficient balance for transfer")
    ErrContractAddressCollision = errors.New("contract address collision")
    ErrNoCompatibleInterpreter  = errors.New("no compatible interpreter")
)

List execution errors

var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{
    common.BytesToAddress([]byte{1}): &ecrecover{},
    common.BytesToAddress([]byte{2}): &sha256hash{},
    common.BytesToAddress([]byte{3}): &ripemd160hash{},
    common.BytesToAddress([]byte{4}): &dataCopy{},
    common.BytesToAddress([]byte{5}): &bigModExp{},
    common.BytesToAddress([]byte{6}): &bn256AddByzantium{},
    common.BytesToAddress([]byte{7}): &bn256ScalarMulByzantium{},
    common.BytesToAddress([]byte{8}): &bn256PairingByzantium{},
}

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

var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract{
    common.BytesToAddress([]byte{1}): &ecrecover{},
    common.BytesToAddress([]byte{2}): &sha256hash{},
    common.BytesToAddress([]byte{3}): &ripemd160hash{},
    common.BytesToAddress([]byte{4}): &dataCopy{},
}

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

var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{
    common.BytesToAddress([]byte{1}): &ecrecover{},
    common.BytesToAddress([]byte{2}): &sha256hash{},
    common.BytesToAddress([]byte{3}): &ripemd160hash{},
    common.BytesToAddress([]byte{4}): &dataCopy{},
    common.BytesToAddress([]byte{5}): &bigModExp{},
    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.

func EnableEIP Uses

func EnableEIP(eipNum int, jt *JumpTable) error

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

func RunPrecompiledContract Uses

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

RunPrecompiledContract runs and evaluates the output of a precompiled contract.

func WriteLogs Uses

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

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

func WriteTrace Uses

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

WriteTrace writes a formatted trace to the given writer

type AccountRef Uses

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 Uses

func (ar AccountRef) Address() common.Address

Address casts AccountRef to a Address

type CallContext Uses

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 Uses

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

CanTransferFunc is the signature of a transfer guard function

type Config Uses

type Config struct {
    Debug                   bool   // Enables debugging
    Tracer                  Tracer // Opcode logger
    NoRecursion             bool   // Disables call, callcode, delegate call and create
    EnablePreimageRecording bool   // Enables recording of SHA3/keccak preimages

    JumpTable [256]operation // EVM instruction table, automatically populated if unset

    EWASMInterpreter string // External EWASM interpreter options
    EVMInterpreter   string // External EVM interpreter options

    ExtraEips []int // Additional EIPS that are to be enabled
}

Config are the configuration options for the Interpreter

type Context Uses

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

    // Message information
    Origin   common.Address // Provides information for ORIGIN
    GasPrice *big.Int       // Provides information for GASPRICE

    // Block information
    Coinbase    common.Address // Provides information for COINBASE
    GasLimit    uint64         // Provides information for GASLIMIT
    BlockNumber *big.Int       // Provides information for NUMBER
    Time        *big.Int       // Provides information for TIME
    Difficulty  *big.Int       // Provides information for DIFFICULTY
}

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

type Contract Uses

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 Uses

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 Uses

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

Address returns the contracts address

func (*Contract) AsDelegate Uses

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 Uses

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 Uses

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

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

func (*Contract) GetOp Uses

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

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

func (*Contract) SetCallCode Uses

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 Uses

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 Uses

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

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

func (*Contract) Value Uses

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

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

type ContractRef Uses

type ContractRef interface {
    Address() common.Address
}

ContractRef is a reference to the contract's backing object

type EVM Uses

type EVM struct {
    // Context provides auxiliary blockchain related information
    Context
    // StateDB gives access to the underlying state
    StateDB StateDB
    // contains filtered or unexported fields
}

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

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

func NewEVM Uses

func NewEVM(ctx Context, statedb StateDB, chainConfig *params.ChainConfig, vmConfig Config) *EVM

NewEVM returns a new EVM. The returned EVM is not thread safe and should only ever be used *once*.

func (*EVM) Call Uses

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 Uses

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 Uses

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 Uses

func (evm *EVM) Cancelled() bool

Cancelled returns true if Cancel has been called

func (*EVM) ChainConfig Uses

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

ChainConfig returns the environment's chain configuration

func (*EVM) Create Uses

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 Uses

func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)

Create2 creates a new contract using code as deployment code.

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

func (*EVM) DelegateCall Uses

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 Uses

func (evm *EVM) Interpreter() Interpreter

Interpreter returns the current interpreter

func (*EVM) StaticCall Uses

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 Uses

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

EVMInterpreter represents an EVM interpreter

func NewEVMInterpreter Uses

func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter

NewEVMInterpreter returns a new instance of the Interpreter.

func (*EVMInterpreter) CanRun Uses

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 Uses

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

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

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

type GetHashFunc Uses

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 Uses

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 Uses

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

func NewJSONLogger Uses

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 Uses

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

CaptureEnd is triggered at end of execution.

func (*JSONLogger) CaptureFault Uses

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

CaptureFault outputs state information on the logger.

func (*JSONLogger) CaptureStart Uses

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

func (*JSONLogger) CaptureState Uses

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

CaptureState outputs state information on the logger.

type JumpTable Uses

type JumpTable [256]operation

JumpTable contains the EVM opcodes supported at a given fork.

type LogConfig Uses

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

LogConfig are the configuration options for structured logger the EVM

type Memory Uses

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

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

func NewMemory Uses

func NewMemory() *Memory

NewMemory returns a new memory model.

func (*Memory) Data Uses

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

Data returns the backing slice

func (*Memory) GetCopy Uses

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

Get returns offset + size as a new slice

func (*Memory) GetPtr Uses

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

GetPtr returns the offset + size

func (*Memory) Len Uses

func (m *Memory) Len() int

Len returns the length of the backing slice

func (*Memory) Print Uses

func (m *Memory) Print()

Print dumps the content of the memory.

func (*Memory) Resize Uses

func (m *Memory) Resize(size uint64)

Resize resizes the memory to size

func (*Memory) Set Uses

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

Set sets offset + size to value

func (*Memory) Set32 Uses

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

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

type OpCode Uses

type OpCode byte

OpCode is an EVM opcode

const (
    STOP OpCode = iota
    ADD
    MUL
    SUB
    DIV
    SDIV
    MOD
    SMOD
    ADDMOD
    MULMOD
    EXP
    SIGNEXTEND
)

0x0 range - arithmetic ops.

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

    SHA3 = 0x20
)

0x10 range - comparison ops.

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

0x30 range - closure state.

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

0x40 range - block operations.

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

0x50 range - 'storage' and execution.

const (
    PUSH1 OpCode = 0x60 + iota
    PUSH2
    PUSH3
    PUSH4
    PUSH5
    PUSH6
    PUSH7
    PUSH8
    PUSH9
    PUSH10
    PUSH11
    PUSH12
    PUSH13
    PUSH14
    PUSH15
    PUSH16
    PUSH17
    PUSH18
    PUSH19
    PUSH20
    PUSH21
    PUSH22
    PUSH23
    PUSH24
    PUSH25
    PUSH26
    PUSH27
    PUSH28
    PUSH29
    PUSH30
    PUSH31
    PUSH32
    DUP1
    DUP2
    DUP3
    DUP4
    DUP5
    DUP6
    DUP7
    DUP8
    DUP9
    DUP10
    DUP11
    DUP12
    DUP13
    DUP14
    DUP15
    DUP16
    SWAP1
    SWAP2
    SWAP3
    SWAP4
    SWAP5
    SWAP6
    SWAP7
    SWAP8
    SWAP9
    SWAP10
    SWAP11
    SWAP12
    SWAP13
    SWAP14
    SWAP15
    SWAP16
)

0x60 range.

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

0xa0 range - logging ops.

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

unofficial opcodes used for parsing.

const (
    CREATE OpCode = 0xf0 + iota
    CALL
    CALLCODE
    RETURN
    DELEGATECALL
    CREATE2
    STATICCALL = 0xfa

    REVERT       = 0xfd
    SELFDESTRUCT = 0xff
)

0xf0 range - closures.

func StringToOp Uses

func StringToOp(str string) OpCode

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

func (OpCode) IsPush Uses

func (op OpCode) IsPush() bool

IsPush specifies if an opcode is a PUSH opcode.

func (OpCode) IsStaticJump Uses

func (op OpCode) IsStaticJump() bool

IsStaticJump specifies if an opcode is JUMP.

func (OpCode) String Uses

func (op OpCode) String() string

type PrecompiledContract Uses

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

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

type Stack Uses

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 Uses

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

Back returns the n'th item in stack

func (*Stack) Data Uses

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

Data returns the underlying big.Int array.

func (*Stack) Print Uses

func (st *Stack) Print()

Print dumps the content of the stack

type StateDB Uses

type StateDB interface {
    CreateAccount(common.Address)

    SubBalance(common.Address, *big.Int)
    AddBalance(common.Address, *big.Int)
    GetBalance(common.Address) *big.Int

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

    GetCodeHash(common.Address) common.Hash
    GetCode(common.Address) []byte
    SetCode(common.Address, []byte)
    GetCodeSize(common.Address) int

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

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

    Suicide(common.Address) bool
    HasSuicided(common.Address) bool

    // Exist reports whether the given account exists in state.
    // Notably this should also return true for suicided accounts.
    Exist(common.Address) bool
    // Empty returns whether the given account is empty. Empty
    // is defined according to EIP161 (balance = nonce = code = 0).
    Empty(common.Address) bool

    RevertToSnapshot(int)
    Snapshot() int

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

    ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error
}

StateDB is an EVM database for full state querying.

type Storage Uses

type Storage map[common.Hash]common.Hash

Storage represents a contract's storage.

func (Storage) Copy Uses

func (s Storage) Copy() Storage

Copy duplicates the current storage.

type StructLog Uses

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

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

func (*StructLog) ErrorString Uses

func (s *StructLog) ErrorString() string

ErrorString formats the log's error as a string.

func (StructLog) MarshalJSON Uses

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

MarshalJSON marshals as JSON.

func (*StructLog) OpName Uses

func (s *StructLog) OpName() string

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

func (*StructLog) UnmarshalJSON Uses

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

UnmarshalJSON unmarshals from JSON.

type StructLogger Uses

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 Uses

func NewStructLogger(cfg *LogConfig) *StructLogger

NewStructLogger returns a new logger

func (*StructLogger) CaptureEnd Uses

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 Uses

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

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

func (*StructLogger) CaptureStart Uses

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 Uses

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

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

CaptureState also tracks SSTORE ops to track dirty values.

func (*StructLogger) Error Uses

func (l *StructLogger) Error() error

Error returns the VM error captured by the trace.

func (*StructLogger) Output Uses

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

Output returns the VM return value captured by the trace.

func (*StructLogger) StructLogs Uses

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

StructLogs returns the captured log entries.

type Tracer Uses

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

Tracer is used to collect execution traces from an EVM transaction execution. CaptureState is called for each step of the VM with the current VM state. Note that reference types are actual VM data structures; make copies if you need to retain them beyond the current call.

type TransferFunc Uses

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

TransferFunc is the signature of a transfer function

Directories

PathSynopsis
runtimePackage runtime provides a basic execution model for executing EVM code.

Package vm imports 23 packages (graph) and is imported by 1633 packages. Updated 2019-11-27. Refresh now. Tools for package owners.