vm

package

Go to main page

Versions in this module

v1

v1.4.4

Dec 16, 2024

v1.4.2

Oct 18, 2023

v1.4.1

Jul 19, 2023

Changes in this version

+ var PrecompiledAddressesBerlin []common.Address

+ var PrecompiledAddressesBerlin2 []common.Address

+ var PrecompiledAddressesByzantium []common.Address

+ var PrecompiledAddressesHomestead []common.Address

+ var PrecompiledContractsBerlin2 = map[common.Address]PrecompiledContract

+ func ActivePrecompiles(state xcom.StateDB) []common.Address

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

+ 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 ScopeContext struct

+ Contract *Contract

+ Memory *Memory

+ Stack *Stack

type StateDB

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

v1.4.0

Mar 17, 2023

v1.3.2

Jan 6, 2023

Changes in this version

+ const ColdAccountAccessCostEIP2929

+ const ColdSloadCostEIP2929

+ const WarmStorageReadCostEIP2929

+ var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract

+ type BlockContext struct

+ BlockHash common.Hash

+ BlockNumber *big.Int

+ CanTransfer CanTransferFunc

+ Coinbase common.Address

+ Ctx context.Context

+ Difficulty *big.Int

+ GasLimit uint64

+ GetHash GetHashFunc

+ GetNonce GetNonceFunc

+ Nonce types.BlockNonce

+ ParentHash common.Hash

+ Time *big.Int

+ Transfer TransferFunc

type Config

+ ExtraEips []int

type EVM

+ Context BlockContext

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

type LogConfig

+ Overrides *params.ChainConfig

type StateDB

+ AddAddressToAccessList func(addr common.Address)

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

+ AddressInAccessList func(addr common.Address) bool

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

+ type TxContext struct

+ GasPrice *big.Int

+ Origin common.Address

v1.3.1

Nov 30, 2022

v1.3.0

Oct 12, 2022

Changes in this version

+ const QueryDelegationLock

+ const TxRedeemDelegation

type StakingContract

+ func (stkc *StakingContract) FnSignsV1() map[uint16]interface{}

v1.2.2

Apr 29, 2022

v1.2.1

Apr 8, 2022

v1.2.0

Mar 31, 2022

Changes in this version

+ var PlatONPrecompiledContracts120 = map[common.Address]PrecompiledContract

type Context

+ GetNonce GetNonceFunc

+ Nonce types.BlockNonce

+ ParentHash common.Hash

+ type GetNonceFunc func(uint64) []byte

type VMContext

+ func NewVMContext(evm *EVM, contract *Contract, config Config, db StateDB) *VMContext

v1.1.3

Feb 11, 2022

v1.1.2

Dec 2, 2021

v1.1.1

Oct 15, 2021

Changes in this version

+ 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

v1.1.0

Jul 23, 2021

Changes in this version

+ const TxWithdrewDelegation

type StateDB

+ GetCurrentActiveVersion func() uint32

v1.0.0

Apr 24, 2021

Changes in this version

+ const Block

+ const Br

+ const BrIf

+ const BrTable

+ const Call

+ const CallIndirect

+ const CurrentMemory

+ const Drop

+ const Else

+ const End

+ const F32Abs

+ const F32Add

+ const F32Ceil

+ const F32Const

+ const F32ConvertSI32

+ const F32ConvertSI64

+ const F32ConvertUI32

+ const F32ConvertUI64

+ const F32Copysign

+ const F32DemoteF64

+ const F32Div

+ const F32Eq

+ const F32Floor

+ const F32Ge

+ const F32Gt

+ const F32Le

+ const F32Load

+ const F32Lt

+ const F32Max

+ const F32Min

+ const F32Mul

+ const F32Ne

+ const F32Nearest

+ const F32Neg

+ const F32ReinterpretI32

+ const F32Sqrt

+ const F32Store

+ const F32Sub

+ const F32Trunc

+ const F64Abs

+ const F64Add

+ const F64Ceil

+ const F64Const

+ const F64ConvertSI32

+ const F64ConvertSI64

+ const F64ConvertUI32

+ const F64ConvertUI64

+ const F64Copysign

+ const F64Div

+ const F64Eq

+ const F64Floor

+ const F64Ge

+ const F64Gt

+ const F64Le

+ const F64Load

+ const F64Lt

+ const F64Max

+ const F64Min

+ const F64Mul

+ const F64Ne

+ const F64Nearest

+ const F64Neg

+ const F64PromoteF32

+ const F64ReinterpretI64

+ const F64Sqrt

+ const F64Store

+ const F64Sub

+ const F64Trunc

+ const GetGlobal

+ const GetLocal

+ const GrowMemory

+ const I32Add

+ const I32And

+ const I32Clz

+ const I32Const

+ const I32Ctz

+ const I32DivS

+ const I32DivU

+ const I32Eq

+ const I32Eqz

+ const I32GeS

+ const I32GeU

+ const I32GtS

+ const I32GtU

+ const I32LeS

+ const I32LeU

+ const I32Load

+ const I32Load16s

+ const I32Load16u

+ const I32Load8s

+ const I32Load8u

+ const I32LtS

+ const I32LtU

+ const I32Mul

+ const I32Ne

+ const I32Or

+ const I32Popcnt

+ const I32ReinterpretF32

+ const I32RemS

+ const I32RemU

+ const I32Rotl

+ const I32Rotr

+ const I32Shl

+ const I32ShrS

+ const I32ShrU

+ const I32Store

+ const I32Store16

+ const I32Store8

+ const I32Sub

+ const I32TruncSF32

+ const I32TruncSF64

+ const I32TruncUF32

+ const I32TruncUF64

+ const I32WrapI64

+ const I32Xor

+ const I64Add

+ const I64And

+ const I64Clz

+ const I64Const

+ const I64Ctz

+ const I64DivS

+ const I64DivU

+ const I64Eq

+ const I64Eqz

+ const I64ExtendSI32

+ const I64ExtendUI32

+ const I64GeS

+ const I64GeU

+ const I64GtS

+ const I64GtU

+ const I64LeS

+ const I64LeU

+ const I64Load

+ const I64Load16s

+ const I64Load16u

+ const I64Load32s

+ const I64Load32u

+ const I64Load8s

+ const I64Load8u

+ const I64LtS

+ const I64LtU

+ const I64Mul

+ const I64Ne

+ const I64Or

+ const I64Popcnt

+ const I64ReinterpretF64

+ const I64RemS

+ const I64RemU

+ const I64Rotl

+ const I64Rotr

+ const I64Shl

+ const I64ShrS

+ const I64ShrU

+ const I64Store

+ const I64Store16

+ const I64Store32

+ const I64Store8

+ const I64Sub

+ const I64TruncSF32

+ const I64TruncSF64

+ const I64TruncUF32

+ const I64TruncUF64

+ const I64Xor

+ const If

+ const InterpTypeLen

+ const Loop

+ const MigrateContractGas

+ const Nop

+ const Return

+ const Select

+ const SetGlobal

+ const SetLocal

+ const TeeLocal

+ const Unreachable

+ const WasmTopicNum

+ var ErrAbort = errors.New("vm exec abort")

+ var ErrExecBadContract = errors.New("exec bad contract")

+ 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 ErrUnderPrice = errors.New("gas price is lower than minimum")

+ var ErrWASMEventContentToLong = errors.New("WASM: event indexed content too long")

+ var ErrWASMEventCountToLarge = errors.New("WASM: event indexed count too large")

+ var ErrWASMMigrate = errors.New("WASM: failed to migrate contract")

+ var ErrWASMOldContractCodeNotExists = errors.New("WASM: old contract code is not exists")

+ var ErrWASMPanicOp = errors.New("WASM: transaction err op")

+ var ErrWASMRlpItemCountTooLarge = errors.New("WASM: itemCount too large for RLP")

+ var ErrWASMSha3DstToShort = errors.New("WASM: sha3 dst len too short")

+ var ErrWASMUndefinedPanic = errors.New("WASM: vm undefined err")

+ var ErrWASMWriteProtection = errors.New("WASM: write protection")

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

+ var EvmInterpNew = BytesToInterpType([]byte{ ... })

+ var EvmInterpOld = BytesToInterpType([]byte{ ... })

+ var WasmGasCostTable [255]uint64

+ var WasmInstrString = map[byte]string

+ var WasmInterp = BytesToInterpType([]byte{ ... })

+ func Address(proc *exec.Process, dst uint32)

+ func Balance(proc *exec.Process, dst uint32, balance uint32) uint32

+ func BlockHash(proc *exec.Process, num uint64, dst uint32)

+ func BlockNumber(proc *exec.Process) uint64

+ func CallContract(proc *exec.Process, ...) int32

+ func CallValue(proc *exec.Process, dst uint32) uint32

+ func Caller(proc *exec.Process, dst uint32)

+ func CallerNonce(proc *exec.Process) uint64

+ func CanUseEVMInterp(b []byte) bool

+ func CanUseWASMInterp(b []byte) bool

+ func Coinbase(proc *exec.Process, dst uint32)

+ func ContractCode(proc *exec.Process, addrPtr uint32, code uint32, codeLen uint32) int32

+ func ContractCodeLength(proc *exec.Process, addrPtr uint32) uint32

+ func CreateContract(proc *exec.Process, newAddr, val, valLen, callCost, callCostLen uint32, ...) int32

+ func Debug(proc *exec.Process, dst uint32, len uint32)

+ func DelegateCallContract(proc *exec.Process, addrPtr, params, paramsLen, callCost, callCostLen uint32) int32

+ func DestroyContract(proc *exec.Process, addrPtr uint32) int32

+ func Ecrecover(proc *exec.Process, hashPtr, sigPtr, sigLen, addrPtr uint32) int32

+ func EmitEvent(proc *exec.Process, indexesPtr, indexesLen, args, argsLen uint32)

+ func Gas(proc *exec.Process) uint64

+ func GasLimit(proc *exec.Process) uint64

+ func GasPrice(proc *exec.Process, gasPrice uint32) uint32

+ func GetCallOutput(proc *exec.Process, dst uint32)

+ func GetCallOutputLength(proc *exec.Process) uint32

+ func GetInput(proc *exec.Process, dst uint32)

+ func GetInputLength(proc *exec.Process) uint32

+ func GetState(proc *exec.Process, key uint32, keyLen uint32, val uint32, valLen uint32) int32

+ func GetStateLength(proc *exec.Process, key uint32, keyLen uint32) uint32

+ func IsEVMPrecompiledContract(addr common.Address) bool

+ func IsPlatONPrecompiledContract(addr common.Address) bool

+ func IsPrecompiledContract(addr common.Address) bool

+ func MigrateCloneContract(proc *exec.Process, ...) int32

+ func MigrateContract(proc *exec.Process, ...) int32

+ func MigrateInnerContract(proc *exec.Process, newAddr, val, valLen, callCost, callCostLen uint32, ...) int32

+ func NewHostModule() *wasm.Module

+ func NewWasmEngineCreator(vm WasmInsType) (wasmEngineCreator, error)

+ func Origin(proc *exec.Process, dst uint32)

+ func Panic(proc *exec.Process)

+ func PlatonClone(proc *exec.Process, ...) int32

+ func PlatonDeploy(proc *exec.Process, ...) int32

+ func ReadWasmModule(Code []byte, verify bool) (*exec.CompiledModule, error)

+ func ReturnContract(proc *exec.Process, dst uint32, len uint32)

+ func Revert(proc *exec.Process)

+ func Ripemd160(proc *exec.Process, inputPtr, inputLen uint32, outputPtr uint32)

+ func RlpBytes(proc *exec.Process, src uint32, length uint32, dest uint32)

+ func RlpBytesSize(proc *exec.Process, src uint32, length uint32) uint32

+ func RlpList(proc *exec.Process, src uint32, length uint32, dest uint32)

+ func RlpListSize(proc *exec.Process, length uint32) uint32

+ func RlpU128(proc *exec.Process, heigh uint64, low uint64, dest uint32)

+ func RlpU128Size(proc *exec.Process, heigh uint64, low uint64) uint32

+ func SetState(proc *exec.Process, key uint32, keyLen uint32, val uint32, valLen uint32)

+ func Sha256(proc *exec.Process, inputPtr, inputLen uint32, outputPtr uint32)

+ func Sha3(proc *exec.Process, src uint32, srcLen uint32, dst uint32, dstLen uint32)

+ func StaticCallContract(proc *exec.Process, addrPtr, params, paramsLen, callCost, callCostLen uint32) int32

+ func Timestamp(proc *exec.Process) int64

+ func Transfer(proc *exec.Process, dst uint32, amount uint32, len uint32) int32

type Config

+ VmTimeoutDuration uint64

+ WasmType WasmInsType

type Context

+ Ctx context.Context

type Contract

+ DeployContract bool

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

type EVM

+ SnapshotDB snapshotdb.DB

+ func (evm *EVM) Cancelled() bool

+ func (evm *EVM) DBSnapshot() (snapshotID int, StateDBID int)

+ func (evm *EVM) GetVMConfig() Config

+ func (evm *EVM) RevertToDBSnapshot(snapshotDBID, stateDBID int)

+ 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 InterpType [InterpTypeLen]byte

+ func BytesToInterpType(b []byte) InterpType

+ func (t *InterpType) SetBytes(b []byte)

+ func (t InterpType) Bytes() []byte

+ func (t InterpType) String() string

+ type JumpTable [256]*operation

type LogConfig

+ DisableReturnData bool

type Memory

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

type OpCode

+ const BEGINSUB

+ const CHAINID

+ const JUMPSUB

+ const RETURNSUB

+ const SELFBALANCE

+ type PrecompiledContractCheck struct

+ func (pcc *PrecompiledContractCheck) IsPlatONPrecompiledContract(address common.Address) bool

+ type ProofList [][]byte

+ func (n *ProofList) Put(key []byte, value []byte) error

+ type ReturnStack struct

type StateDB

+ GetLogs func(hash common.Hash) []*types.Log

+ MigrateStorage func(from, to common.Address)

type StructLog

+ RefundCounter uint64

+ ReturnData []byte

+ ReturnStack []uint32

+ type VMContext struct

+ CallOut []byte

+ Input []byte

+ Log *WasmLogger

+ Output []byte

+ Revert bool

+ type WasmDeploy struct

+ Args [][]byte

+ VM byte

+ type WasmInoke struct

+ Args *WasmParams

+ VM byte

+ type WasmInsType byte

+ const Unknown

+ const Wagon

+ func Str2WasmType(str string) WasmInsType

+ func (t WasmInsType) String() string

+ type WasmParams struct

+ Args [][]byte

+ FuncName []byte

v0

v0.7.6

Jan 14, 2020

Changes in this version

+ const FuncNameDelegateReward

+ const FuncNameWithdrawDelegateReward

+ const QueryDelegateReward

+ const TxWithdrawDelegateReward

+ type DelegateRewardContract struct

+ Contract *Contract

+ Evm *EVM

+ Plugin *plugin.RewardMgrPlugin

+ func (rc *DelegateRewardContract) CheckGasPrice(gasPrice *big.Int, fcode uint16) error

+ func (rc *DelegateRewardContract) FnSigns() map[uint16]interface{}

+ func (rc *DelegateRewardContract) RequiredGas(input []byte) uint64

+ func (rc *DelegateRewardContract) Run(input []byte) ([]byte, error)

v0.7.5

Dec 13, 2019

Changes in this version

+ const GetAvgPackTime

+ const GetPackageReward

+ const GetStakingReward

v0.7.4

Nov 19, 2019

Changes in this version

+ const CheckDuplicateSign

+ const GetGovernParamValue

+ const ListGovernParam

+ const QueryCandidateInfo

+ const QueryCandidateList

+ const QueryDelegateInfo

+ const QueryRelateList

+ const QueryRestrictingInfo

+ const QueryValidatorList

+ const QueryVerifierList

+ const SubmitParam

+ const TxCreateRestrictingPlan

+ const TxCreateStaking

+ const TxDelegate

+ const TxEditorCandidate

+ const TxIncreaseStaking

+ const TxReportDuplicateSign

+ const TxWithdrewCandidate

+ const TxWithdrewDelegate

+ func IsBlank(i interface{}) bool

v0.7.3

Oct 21, 2019

Changes in this version

+ const BLSPROOFLEN

v0.7.1

Sep 7, 2019

Changes in this version

+ const AmountIllegalErrStr

+ const BLSPUBKEYLEN

+ const CanAlreadyExistsErrStr

+ const CanNoAllowDelegateErrStr

+ const CanNotExistErrStr

+ const CanStatusInvalidErrStr

+ const CheckDuplicateSignEvent

+ const CreateCanErrStr

+ const CreateRestrictingPlanEvent

+ const CreateStakingEvent

+ const Declare

+ const DeclareErrorMsg

+ const DelegateErrStr

+ const DelegateEvent

+ const DelegateNotExistErrStr

+ const DelegateVonTooLowStr

+ const DescriptionLenErrStr

+ const EditCanErrStr

+ const EditorCandidateEvent

+ const GetAccuVerifiersCount

+ const GetAccuVerifiersCountErrorMsg

+ const GetActiveVersion

+ const GetActiveVersionErrorMsg

+ const GetCandidateListErrStr

+ const GetDelegateRelatedErrStr

+ const GetProgramVersion

+ const GetProgramVersionErrorMsg

+ const GetProposal

+ const GetProposalErrorMsg

+ const GetResult

+ const GetTallyResultErrorMsg

+ const GetValidatorListErrStr

+ const GetVerifierListErrStr

+ const IncreaseStakingErrStr

+ const IncreaseStakingEvent

+ const ListProposal

+ const ListProposalErrorMsg

+ const ProgramVersionErrStr

+ const ProgramVersionSignErrStr

+ const QueryCanErrStr

+ const QueryDelErrSTr

+ const ReportDuplicateSignEvent

+ const StakeVonTooLowStr

+ const StakingAddrNoSomeErrStr

+ const SubmitCancel

+ const SubmitCancelProposalErrorMsg

+ const SubmitParamProposalErrorMsg

+ const SubmitText

+ const SubmitTextProposalErrorMsg

+ const SubmitVersion

+ const SubmitVersionProposalErrorMsg

+ const Vote

+ const VoteErrorMsg

+ const WithdrewCanErrStr

+ const WithdrewCandidateEvent

+ const WithdrewDelegateErrStr

+ const WithdrewDelegateEvent

+ const WrongBlsPubKeyStr

+ var Delimiter = []byte("")

+ var PlatONPrecompiledContracts = map[common.Address]PrecompiledContract

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

type Context

+ BlockHash common.Hash

+ type GovContract struct

+ Contract *Contract

+ Evm *EVM

+ Plugin *plugin.GovPlugin

+ func (gc *GovContract) CheckGasPrice(gasPrice *big.Int, fcode uint16) error

+ func (gc *GovContract) FnSigns() map[uint16]interface{}

+ func (gc *GovContract) RequiredGas(input []byte) uint64

+ func (gc *GovContract) Run(input []byte) ([]byte, error)

+ type PlatONPrecompiledContract interface

+ CheckGasPrice func(gasPrice *big.Int, fcode uint16) error

+ FnSigns func() map[uint16]interface{}

+ type RestrictingContract struct

+ Contract *Contract

+ Evm *EVM

+ Plugin *plugin.RestrictingPlugin

+ func (rc *RestrictingContract) CheckGasPrice(gasPrice *big.Int, fcode uint16) error

+ func (rc *RestrictingContract) FnSigns() map[uint16]interface{}

+ func (rc *RestrictingContract) RequiredGas(input []byte) uint64

+ func (rc *RestrictingContract) Run(input []byte) ([]byte, error)

+ type SlashingContract struct

+ Contract *Contract

+ Evm *EVM

+ Plugin *plugin.SlashingPlugin

+ func (sc *SlashingContract) CheckDuplicateSign(dupType uint8, addr common.Address, blockNumber uint64) ([]byte, error)

+ func (sc *SlashingContract) CheckGasPrice(gasPrice *big.Int, fcode uint16) error

+ func (sc *SlashingContract) FnSigns() map[uint16]interface{}

+ func (sc *SlashingContract) ReportDuplicateSign(dupType uint8, data string) ([]byte, error)

+ func (sc *SlashingContract) RequiredGas(input []byte) uint64

+ func (sc *SlashingContract) Run(input []byte) ([]byte, error)

+ type StakingContract struct

+ Contract *Contract

+ Evm *EVM

+ Plugin *plugin.StakingPlugin

+ func (stkc *StakingContract) CheckGasPrice(gasPrice *big.Int, fcode uint16) error

+ func (stkc *StakingContract) FnSigns() map[uint16]interface{}

+ func (stkc *StakingContract) RequiredGas(input []byte) uint64

+ func (stkc *StakingContract) Run(input []byte) ([]byte, error)

type StateDB

+ IntermediateRoot func(deleteEmptyObjects bool) common.Hash

type ValidateNode

+ BlsPubKey bls.PublicKey

v0.7.0

Jun 17, 2019

Changes in this version

+ const CALL_CANTRACT_FLAG

+ const CurrentValidatorKey

+ const NextValidatorKey

+ var DEFAULT_VM_CONFIG = exec.VMConfig

+ var PrecompiledContractsValidator = map[common.Address]PrecompiledContract

+ var ValidatorInnerContractAddr = common.HexToAddress("0x2000000000000000000000000000000000000000")

type Config

+ ConsoleOutput bool

type Contract

+ ABI []byte

+ ABIAddr *common.Address

+ ABIHash common.Hash

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

+ type ContractRefCaller struct

+ func (c ContractRefCaller) Address() common.Address

+ type ContractRefSelf struct

+ func (c ContractRefSelf) Address() common.Address

type EVM

+ func (evm *EVM) GetConfig() Config

+ func (evm *EVM) GetEvm() *EVM

+ func (evm *EVM) GetStateDB() StateDB

+ type NodeList []*ValidateNode

+ func (nl *NodeList) String() string

type StateDB

+ GetAbi func(common.Address) []byte

+ GetAbiHash func(common.Address) common.Hash

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

+ TxHash func() common.Hash

+ TxIdx func() uint32

+ type StateDBTest struct

+ type ValidateNode struct

+ Address common.Address

+ Index uint

+ NodeID discover.NodeID

+ type ValidatorInnerContractBase interface

+ CurrentValidators func() (*Validators, error)

+ NextValidators func() (*Validators, error)

+ SwitchValidators func(validBlockNumber uint64) error

+ UpdateValidators func(validators *Validators) error

+ type Validators struct

+ ValidBlockNumber uint64

+ ValidateNodes NodeList

+ func (vds *Validators) String() string

+ type WASMInterpreter struct

+ WasmLogger log.Logger

+ func NewWASMInterpreter(evm *EVM, cfg Config) *WASMInterpreter

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

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

+ type WasmLogger struct

+ func NewWasmLogger(cfg Config, root log.Logger) *WasmLogger

+ func (wl *WasmLogger) Crit(msg string, ctx ...interface{})

+ func (wl *WasmLogger) Debug(msg string, ctx ...interface{})

+ func (wl *WasmLogger) Error(msg string, ctx ...interface{})

+ func (wl *WasmLogger) Flush()

+ func (wl *WasmLogger) GetHandler() log.Handler

+ func (wl *WasmLogger) Info(msg string, ctx ...interface{})

+ func (wl *WasmLogger) New(ctx ...interface{}) log.Logger

+ func (wl *WasmLogger) SetHandler(h log.Handler)

+ func (wl *WasmLogger) Trace(msg string, ctx ...interface{})

+ func (wl *WasmLogger) Warn(msg string, ctx ...interface{})

+ type WasmStateDB struct

+ StateDB StateDB

+ func NewWasmStateDB(db *WasmStateDB, contract ContractRef) *WasmStateDB

+ func (self *WasmStateDB) AddLog(address common.Address, topics []common.Hash, data []byte, bn uint64)

+ func (self *WasmStateDB) Address() common.Address

+ func (self *WasmStateDB) BlockHash(num uint64) common.Hash

+ func (self *WasmStateDB) BlockNumber() *big.Int

+ func (self *WasmStateDB) Call(addr, param []byte) ([]byte, error)

+ func (self *WasmStateDB) CallValue() *big.Int

+ func (self *WasmStateDB) Caller() common.Address

+ func (self *WasmStateDB) Coinbase() common.Address

+ func (self *WasmStateDB) DelegateCall(addr, param []byte) ([]byte, error)

+ func (self *WasmStateDB) GasLimimt() uint64

+ func (self *WasmStateDB) GasPrice() int64

+ func (self *WasmStateDB) GetBalance(addr common.Address) *big.Int

+ func (self *WasmStateDB) GetCallerNonce() int64

+ func (self *WasmStateDB) GetState(key []byte) []byte

+ func (self *WasmStateDB) Origin() common.Address

+ func (self *WasmStateDB) SetState(key []byte, value []byte)

+ func (self *WasmStateDB) Time() *big.Int

+ func (self *WasmStateDB) Transfer(toAddr common.Address, value *big.Int) (ret []byte, leftOverGas uint64, err error)

v0.0.0

Sep 24, 2018

Changes in this version

+ const GasContractByte

+ const GasExtStep

+ const GasFastStep

+ const GasFastestStep

+ const GasMidStep

+ const GasQuickStep

+ const GasReturn

+ const GasSlowStep

+ const GasStop

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

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

+ 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 Config struct

+ Debug bool

+ EVMInterpreter string

+ EWASMInterpreter string

+ EnablePreimageRecording bool

+ JumpTable [256]operation

+ NoRecursion bool

+ Tracer Tracer

+ type Context struct

+ BlockNumber *big.Int

+ CanTransfer CanTransferFunc

+ Coinbase common.Address

+ Difficulty *big.Int

+ GasLimit uint64

+ GasPrice *big.Int

+ GetHash GetHashFunc

+ Origin common.Address

+ Time *big.Int

+ Transfer TransferFunc

+ type Contract struct

+ Args []byte

+ CallerAddress common.Address

+ Code []byte

+ CodeAddr *common.Address

+ CodeHash common.Hash

+ DelegateCall bool

+ 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) SetCode(hash common.Hash, code []byte)

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

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

+ const BYTE

+ const CALL

+ const CALLCODE

+ const CALLDATACOPY

+ const CALLDATALOAD

+ const CALLDATASIZE

+ const CALLER

+ const CALLVALUE

+ const CODECOPY

+ const CODESIZE

+ const COINBASE

+ const CREATE

+ const CREATE2

+ const DELEGATECALL

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

+ const RETURNDATACOPY

+ const RETURNDATASIZE

+ const REVERT

+ const SAR

+ const SDIV

+ const SELFDESTRUCT

+ const SGT

+ const SHA3

+ const SHL

+ const SHR

+ const SIGNEXTEND

+ const SLOAD

+ const SLT

+ const SMOD

+ const SSTORE

+ const STATICCALL

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

+ AddLog func(*types.Log)

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

+ AddRefund func(uint64)

+ CreateAccount func(common.Address)

+ Empty func(common.Address) bool

+ Exist func(common.Address) bool

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

+ GetBalance func(common.Address) *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

+ RevertToSnapshot func(int)

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

+ SetNonce func(common.Address, uint64)

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

+ Snapshot func() int

+ SubBalance func(common.Address, *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

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

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL