vm

May 23, 2024

Changes in this version

type BlockContext

+ BlobBaseFee *big.Int

type OpCode

+ const BLOBBASEFEE

type TxContext

+ BlobFeeCap *big.Int

Mar 25, 2024

Changes in this version

+ var PrecompiledAddressesBLS []common.Address

+ var PrecompiledAddressesCancun []common.Address

+ var PrecompiledContractsBLS = map[common.Address]contract.StatefulPrecompiledContract

+ var PrecompiledContractsCancun = map[common.Address]contract.StatefulPrecompiledContract

type BlockContext

+ ExcessBlobGas *uint64

type Memory

+ func (m *Memory) Copy(dst, src, len uint64)

type OpCode

+ const BLOBHASH

+ const MCOPY

type StateDB

+ HasSelfDestructed func(common.Address) bool

+ SelfDestruct func(common.Address)

+ Selfdestruct6780 func(common.Address)

type TxContext

+ BlobHashes []common.Hash

Jan 10, 2024

Changes in this version

type BlockContext

+ PredicateResults *predicate.Results

+ func (b *BlockContext) GetPredicateResults(txHash common.Hash, address common.Address) []byte

type EVM

+ func (evm *EVM) GetChainConfig() precompileconfig.ChainConfig

+ func (evm *EVM) GetSnowContext() *snow.Context

type StateDB

+ GetLogData func() (topics [][]common.Hash, data [][]byte)

+ GetPredicateStorageSlots func(address common.Address, index int) ([]byte, bool)

+ GetTxHash func() common.Hash

+ SetPredicateStorageSlots func(address common.Address, predicates [][]byte)

Sep 21, 2023

Changes in this version

type JumpTable

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

Jun 14, 2023

Changes in this version

type EVM

+ func (evm *EVM) SetBlockContext(blockCtx BlockContext)

type OpCode

+ const TLOAD

+ const TSTORE

type StateDB

+ GetTransientState func(addr common.Address, key common.Hash) common.Hash

+ Prepare func(rules params.Rules, sender, coinbase common.Address, dest *common.Address, ...)

+ SetTransientState func(addr common.Address, key, value common.Hash)

Nov 17, 2022

Changes in this version

+ var PrecompiledAddressesApricotPhase6 []common.Address

+ var PrecompiledAddressesApricotPhasePre6 []common.Address

+ var PrecompiledContractsApricotPhase6 = map[common.Address]precompile.StatefulPrecompiledContract

+ var PrecompiledContractsApricotPhasePre6 = map[common.Address]precompile.StatefulPrecompiledContract

Sep 28, 2022

Changes in this version

+ var PrecompiledAddressesBanff []common.Address

+ var PrecompiledContractsBanff = map[common.Address]precompile.StatefulPrecompiledContract

Sep 13, 2022

Changes in this version

+ var PrecompiledAddressesBlueberry []common.Address

+ var PrecompiledContractsBlueberry = map[common.Address]precompile.StatefulPrecompiledContract

Aug 8, 2022

Changes in this version

+ var PrecompileAllNativeAddresses map[common.Address]struct

+ func IsProhibited(addr common.Address) bool

+ func RunStatefulPrecompiledContract(precompile precompile.StatefulPrecompiledContract, ...) (ret []byte, remainingGas uint64, err error)

type BlockContext

+ func (b *BlockContext) Number() *big.Int

+ func (b *BlockContext) Timestamp() *big.Int

type EVM

+ func (evm *EVM) GetBlockContext() precompile.BlockContext

+ func (evm *EVM) GetStateDB() precompile.StateDB

+ func (evm *EVM) NativeAssetCall(caller common.Address, input []byte, suppliedGas uint64, gasCost uint64, ...) (ret []byte, remainingGas uint64, err error)

Jul 1, 2022

Changes in this version

type EVMLogger

+ CaptureTxEnd func(restGas uint64)

+ CaptureTxStart func(gasLimit uint64)

type OpCode

+ const PUSH0

Feb 3, 2022

Changes in this version

+ var NativeAssetBalanceAddr = common.HexToAddress("0x0100000000000000000000000000000000000001")

+ var NativeAssetCallAddr = common.HexToAddress("0x0100000000000000000000000000000000000002")

Jan 19, 2022

Changes in this version

+ var ErrNoSenderBlackhole = errors.New("blackhole address cannot be used as sender")

+ var ErrNonceUintOverflow = errors.New("nonce uint64 overflow")

type OpCode

+ const INVALID

+ const KECCAK256

Nov 10, 2021

Changes in this version

+ type EVMLogger interface

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

+ CaptureEnter func(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, ...)

+ CaptureExit func(output []byte, gasUsed uint64, err error)

+ CaptureFault func(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

+ CaptureStart func(env *EVM, from common.Address, to common.Address, create bool, input []byte, ...)

+ CaptureState func(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

Oct 12, 2021

Changes in this version

type AccessListTracer

+ func (*AccessListTracer) CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, ...)

+ func (*AccessListTracer) CaptureExit(output []byte, gasUsed uint64, err error)

type JSONLogger

+ func (l *JSONLogger) CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, ...)

+ func (l *JSONLogger) CaptureExit(output []byte, gasUsed uint64, err error)

type LogConfig

+ EnableMemory bool

+ EnableReturnData bool

type StructLogger

+ func (l *StructLogger) CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, ...)

+ func (l *StructLogger) CaptureExit(output []byte, gasUsed uint64, err error)

type Tracer

+ CaptureEnter func(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, ...)

+ CaptureExit func(output []byte, gasUsed uint64, err error)

Aug 16, 2021

Changes in this version

+ var ErrInvalidCode = errors.New("invalid code: must not begin with 0xef")

type BlockContext

+ BaseFee *big.Int

type Config

+ NoBaseFee bool

type EVM

+ Config Config

type OpCode

+ const BASEFEE

type StructLogger

+ func (l *StructLogger) Reset()

May 5, 2021

Changes in this version

+ const ColdAccountAccessCostEIP2929

+ const ColdSloadCostEIP2929

+ const WarmStorageReadCostEIP2929

+ var PrecompiledAddressesApricotPhase2 []common.Address

+ var PrecompiledAddressesByzantium []common.Address

+ var PrecompiledAddressesHomestead []common.Address

+ var PrecompiledAddressesIstanbul []common.Address

+ var PrecompiledContractsApricotPhase2 = map[common.Address]StatefulPrecompiledContract

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

+ func PackNativeAssetBalanceInput(address common.Address, assetID common.Hash) []byte

+ func PackNativeAssetCallInput(address common.Address, assetID common.Hash, assetAmount *big.Int, ...) []byte

+ func UnpackNativeAssetBalanceInput(input []byte) (common.Address, common.Hash, error)

+ func UnpackNativeAssetCallInput(input []byte) (common.Address, *common.Hash, *big.Int, []byte, error)

+ type AccessListTracer struct

+ func NewAccessListTracer(acl types.AccessList, from, to common.Address, precompiles []common.Address) *AccessListTracer

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

+ func (*AccessListTracer) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

+ func (a *AccessListTracer) AccessList() types.AccessList

+ func (a *AccessListTracer) CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, ...)

+ func (a *AccessListTracer) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

+ func (a *AccessListTracer) Equal(other *AccessListTracer) bool

+ type BlockContext struct

+ BlockNumber *big.Int

+ CanTransfer CanTransferFunc

+ CanTransferMC CanTransferMCFunc

+ Coinbase common.Address

+ Difficulty *big.Int

+ GasLimit uint64

+ GetHash GetHashFunc

+ Time *big.Int

+ Transfer TransferFunc

+ TransferMultiCoin TransferMCFunc

type EVM

+ Context BlockContext

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

type LogConfig

+ Overrides *params.ChainConfig

+ type ScopeContext struct

+ Contract *Contract

+ Memory *Memory

+ Stack *Stack

type StateDB

+ AddAddressToAccessList func(addr common.Address)

+ AddSlotToAccessList func(addr common.Address, slot common.Hash)

+ AddressInAccessList func(addr common.Address) bool

+ PrepareAccessList func(sender common.Address, dest *common.Address, precompiles []common.Address, ...)

+ SlotInAccessList func(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)

+ type StatefulPrecompiledContract interface

+ Run func(evm *EVM, caller ContractRef, addr common.Address, input []byte, ...) (ret []byte, remainingGas uint64, err error)

+ type TxContext struct

+ GasPrice *big.Int

+ Origin common.Address

Mar 29, 2021

Changes in this version

type Config

+ AllowUnfinalizedQueries bool

Mar 29, 2021

Changes in this version

type StateDB

+ GetCommittedStateAP1 func(common.Address, common.Hash) common.Hash

Sep 19, 2020

Changes in this version

+ var ErrExecutionReverted = errors.New("execution reverted")

+ var ErrGasUintOverflow = errors.New("gas uint64 overflow")

+ var ErrInvalidJump = errors.New("invalid jump destination")

+ var ErrInvalidRetsub = errors.New("invalid retsub")

+ var ErrInvalidSubroutineEntry = errors.New("invalid subroutine entry")

+ var ErrMaxCodeSizeExceeded = errors.New("max code size exceeded")

+ var ErrReturnDataOutOfBounds = errors.New("return data out of bounds")

+ var ErrReturnStackExceeded = errors.New("return stack limit reached")

+ var ErrWriteProtection = errors.New("write protection")

+ var PrecompiledContractsYoloV1 = map[common.Address]PrecompiledContract

+ func ActivateableEips() []string

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

+ func ValidEip(eipNum int) bool

+ type ErrInvalidOpCode struct

+ func (e *ErrInvalidOpCode) Error() string

+ type ErrStackOverflow struct

+ func (e *ErrStackOverflow) Error() string

+ type ErrStackUnderflow struct

+ func (e *ErrStackUnderflow) Error() string

type LogConfig

+ DisableReturnData bool

type Memory

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

type OpCode

+ const BEGINSUB

+ const JUMPSUB

+ const RETURNSUB

+ type ReturnStack struct

type StructLog

+ ReturnData []byte

+ ReturnStack []uint32

Jul 30, 2020

Changes in this version

+ var BuiltinAddr = common.Address

Jul 23, 2020

Changes in this version

+ const CALL

+ const CALLCODE

+ const CALLEX

+ const CREATE

+ const CREATE2

+ const DELEGATECALL

+ const GasExtStep

+ const GasFastStep

+ const GasFastestStep

+ const GasMidStep

+ const GasQuickStep

+ const GasSlowStep

+ const RETURN

+ const REVERT

+ const SELFDESTRUCT

+ const STATICCALL

+ var ErrCodeStoreOutOfGas = errors.New("contract creation code storage out of gas")

+ var ErrContractAddressCollision = errors.New("contract address collision")

+ var ErrDepth = errors.New("max call depth exceeded")

+ var ErrIncompatibleAccount = errors.New("incompatible account")

+ var ErrInsufficientBalance = errors.New("insufficient balance for transfer")

+ var ErrNoCompatibleInterpreter = errors.New("no compatible interpreter")

+ var ErrOutOfGas = errors.New("out of gas")

+ var ErrTraceLimitReached = errors.New("the number of logs reached the specified limit")

+ var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract

+ var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract

+ var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract

+ func EnableEIP(eipNum int, jt *JumpTable) error

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

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

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

+ type AccountRef common.Address

+ func (ar AccountRef) Address() common.Address

+ type CallContext interface

+ Call func(env *EVM, me ContractRef, addr common.Address, data []byte, ...) ([]byte, error)

+ CallCode func(env *EVM, me ContractRef, addr common.Address, data []byte, ...) ([]byte, error)

+ CallExpert func(env *EVM, me ContractRef, addr common.Address, data []byte, ...) ([]byte, error)

+ Create func(env *EVM, me ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error)

+ DelegateCall func(env *EVM, me ContractRef, addr common.Address, data []byte, gas *big.Int) ([]byte, error)

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

+ type CanTransferMCFunc func(StateDB, common.Address, common.Address, *common.Hash, *big.Int) int

+ type Config struct

+ Debug bool

+ EVMInterpreter string

+ EWASMInterpreter string

+ EnablePreimageRecording bool

+ ExtraEips []int

+ JumpTable [256]operation

+ NoRecursion bool

+ Tracer Tracer

+ type Context struct

+ BlockNumber *big.Int

+ CanTransfer CanTransferFunc

+ CanTransferMC CanTransferMCFunc

+ Coinbase common.Address

+ Difficulty *big.Int

+ GasLimit uint64

+ GasPrice *big.Int

+ GetHash GetHashFunc

+ Origin common.Address

+ Time *big.Int

+ Transfer TransferFunc

+ TransferMultiCoin TransferMCFunc

+ type Contract struct

+ CallerAddress common.Address

+ Code []byte

+ CodeAddr *common.Address

+ CodeHash common.Hash

+ Gas uint64

+ Input []byte

+ func NewContract(caller ContractRef, object ContractRef, value *big.Int, gas uint64) *Contract

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

+ func (c *Contract) AsDelegate() *Contract

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

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

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

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

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

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

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

+ type ContractRef interface

+ Address func() common.Address

+ type EVM struct

+ StateDB StateDB

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

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

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

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

+ func (evm *EVM) Cancel()

+ func (evm *EVM) Cancelled() bool

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

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

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

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

+ func (evm *EVM) Interpreter() Interpreter

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

+ type EVMInterpreter struct

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

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

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

+ type GetHashFunc func(uint64) common.Hash

+ type Interpreter interface

+ CanRun func([]byte) bool

+ Run func(contract *Contract, input []byte, static bool) ([]byte, error)

+ type JSONLogger struct

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

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

+ func (l *JSONLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, ...) error

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

+ func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, ...) error

+ type JumpTable [256]operation

+ type LogConfig struct

+ Debug bool

+ DisableMemory bool

+ DisableStack bool

+ DisableStorage bool

+ Limit int

+ type Memory struct

+ func NewMemory() *Memory

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

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

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

+ func (m *Memory) Len() int

+ func (m *Memory) Print()

+ func (m *Memory) Resize(size uint64)

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

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

+ type OpCode byte

+ const ADD

+ const ADDMOD

+ const ADDRESS

+ const AND

+ const BALANCE

+ const BALANCEMC

+ const BLOCKHASH

+ const BYTE

+ const CALLDATACOPY

+ const CALLDATALOAD

+ const CALLDATASIZE

+ const CALLER

+ const CALLVALUE

+ const CHAINID

+ const CODECOPY

+ const CODESIZE

+ const COINBASE

+ const DIFFICULTY

+ const DIV

+ const DUP

+ const DUP1

+ const DUP10

+ const DUP11

+ const DUP12

+ const DUP13

+ const DUP14

+ const DUP15

+ const DUP16

+ const DUP2

+ const DUP3

+ const DUP4

+ const DUP5

+ const DUP6

+ const DUP7

+ const DUP8

+ const DUP9

+ const EMC

+ const EQ

+ const EXP

+ const EXTCODECOPY

+ const EXTCODEHASH

+ const EXTCODESIZE

+ const GAS

+ const GASLIMIT

+ const GASPRICE

+ const GT

+ const ISZERO

+ const JUMP

+ const JUMPDEST

+ const JUMPI

+ const LOG0

+ const LOG1

+ const LOG2

+ const LOG3

+ const LOG4

+ const LT

+ const MLOAD

+ const MOD

+ const MSIZE

+ const MSTORE

+ const MSTORE8

+ const MUL

+ const MULMOD

+ const NOT

+ const NUMBER

+ const OR

+ const ORIGIN

+ const PC

+ const POP

+ const PUSH

+ const PUSH1

+ const PUSH10

+ const PUSH11

+ const PUSH12

+ const PUSH13

+ const PUSH14

+ const PUSH15

+ const PUSH16

+ const PUSH17

+ const PUSH18

+ const PUSH19

+ const PUSH2

+ const PUSH20

+ const PUSH21

+ const PUSH22

+ const PUSH23

+ const PUSH24

+ const PUSH25

+ const PUSH26

+ const PUSH27

+ const PUSH28

+ const PUSH29

+ const PUSH3

+ const PUSH30

+ const PUSH31

+ const PUSH32

+ const PUSH4

+ const PUSH5

+ const PUSH6

+ const PUSH7

+ const PUSH8

+ const PUSH9

+ const RETURNDATACOPY

+ const RETURNDATASIZE

+ const SAR

+ const SDIV

+ const SELFBALANCE

+ const SGT

+ const SHA3

+ const SHL

+ const SHR

+ const SIGNEXTEND

+ const SLOAD

+ const SLT

+ const SMOD

+ const SSTORE

+ const STOP

+ const SUB

+ const SWAP

+ const SWAP1

+ const SWAP10

+ const SWAP11

+ const SWAP12

+ const SWAP13

+ const SWAP14

+ const SWAP15

+ const SWAP16

+ const SWAP2

+ const SWAP3

+ const SWAP4

+ const SWAP5

+ const SWAP6

+ const SWAP7

+ const SWAP8

+ const SWAP9

+ const TIMESTAMP

+ const XOR

+ func StringToOp(str string) OpCode

+ func (op OpCode) IsPush() bool

+ func (op OpCode) IsStaticJump() bool

+ func (op OpCode) String() string

+ type PrecompiledContract interface

+ RequiredGas func(input []byte) uint64

+ Run func(input []byte) ([]byte, error)

+ type Stack struct

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

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

+ func (st *Stack) Print()

+ type StateDB interface

+ AddBalance func(common.Address, *big.Int)

+ AddBalanceMultiCoin func(common.Address, common.Hash, *big.Int)

+ AddLog func(*types.Log)

+ AddPreimage func(common.Hash, []byte)

+ AddRefund func(uint64)

+ CreateAccount func(common.Address)

+ Empty func(common.Address) bool

+ EnableMultiCoin func(common.Address) error

+ Exist func(common.Address) bool

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

+ GetBalance func(common.Address) *big.Int

+ GetBalanceMultiCoin func(common.Address, common.Hash) *big.Int

+ GetCode func(common.Address) []byte

+ GetCodeHash func(common.Address) common.Hash

+ GetCodeSize func(common.Address) int

+ GetCommittedState func(common.Address, common.Hash) common.Hash

+ GetNonce func(common.Address) uint64

+ GetRefund func() uint64

+ GetState func(common.Address, common.Hash) common.Hash

+ HasSuicided func(common.Address) bool

+ IsMultiCoin func(common.Address) bool

+ RevertToSnapshot func(int)

+ SetCode func(common.Address, []byte)

+ SetNonce func(common.Address, uint64)

+ SetState func(common.Address, common.Hash, common.Hash) error

+ Snapshot func() int

+ SubBalance func(common.Address, *big.Int)

+ SubBalanceMultiCoin func(common.Address, common.Hash, *big.Int)

+ SubRefund func(uint64)

+ Suicide func(common.Address) bool

+ type Storage map[common.Hash]common.Hash

+ func (s Storage) Copy() Storage

+ type StructLog struct

+ Depth int

+ Err error

+ Gas uint64

+ GasCost uint64

+ Memory []byte

+ MemorySize int

+ Op OpCode

+ Pc uint64

+ RefundCounter uint64

+ Stack []*big.Int

+ Storage map[common.Hash]common.Hash

+ func (s *StructLog) ErrorString() string

+ func (s *StructLog) OpName() string

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

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

+ type StructLogger struct

+ func NewStructLogger(cfg *LogConfig) *StructLogger

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

+ func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, ...) error

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

+ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, ...) error

+ func (l *StructLogger) Error() error

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

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

+ type Tracer interface

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

+ CaptureFault func(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, ...) error

+ CaptureStart func(from common.Address, to common.Address, call bool, input []byte, gas uint64, ...) error

+ CaptureState func(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, ...) error

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

+ type TransferMCFunc func(StateDB, common.Address, common.Address, *common.Hash, *big.Int)