vm

package
v1.2.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 27, 2024 License: GPL-3.0 Imports: 50 Imported by: 0

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 (
	TxWithdrawDelegateReward       = 5000
	FuncNameWithdrawDelegateReward = "WithdrawDelegateReward"
	QueryDelegateReward            = 5100
	FuncNameDelegateReward         = "QueryDelegateReward"
)
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 (
	SubmitText            = uint16(2000)
	SubmitVersion         = uint16(2001)
	SubmitParam           = uint16(2002)
	Vote                  = uint16(2003)
	Declare               = uint16(2004)
	SubmitCancel          = uint16(2005)
	GetProposal           = uint16(2100)
	GetResult             = uint16(2101)
	ListProposal          = uint16(2102)
	GetActiveVersion      = uint16(2103)
	GetGovernParamValue   = uint16(2104)
	GetAccuVerifiersCount = uint16(2105)
	ListGovernParam       = uint16(2106)
)
View Source 
const (
	TxCreateRestrictingPlan = 4000
	QueryRestrictingInfo    = 4100
)
View Source 
const (
	TxReportDuplicateSign = 3000
	CheckDuplicateSign    = 3001
)
View Source 
const (
	TxCreateStaking      = 1000
	TxEditorCandidate    = 1001
	TxIncreaseStaking    = 1002
	TxWithdrewCandidate  = 1003
	TxDelegate           = 1004
	TxWithdrewDelegation = 1005
	QueryVerifierList    = 1100
	QueryValidatorList   = 1101
	QueryCandidateList   = 1102
	QueryRelateList      = 1103
	QueryDelegateInfo    = 1104
	QueryCandidateInfo   = 1105
	GetPackageReward     = 1200
	GetStakingReward     = 1201
	GetAvgPackTime       = 1202
)
View Source 
const (
	BLSPUBKEYLEN = 96 //  the bls public key length must be 96 byte
	BLSPROOFLEN  = 64 // the bls proof length must be 64 byte
)
View Source 
const (
	CurrentValidatorKey = "current_validator"
	NextValidatorKey    = "next_validator"
)
View Source 
const (
	InterpTypeLen = 4
	WasmTopicNum  = 4
)
View Source 
const (
	Unreachable  = 0x00
	Nop          = 0x01
	Block        = 0x02
	Loop         = 0x03
	If           = 0x04
	Else         = 0x05
	End          = 0x0b
	Br           = 0x0c
	BrIf         = 0x0d
	BrTable      = 0x0e
	Return       = 0x0f
	Call         = 0x10
	CallIndirect = 0x11

	Drop   = 0x1a
	Select = 0x1b

	GetLocal  = 0x20
	SetLocal  = 0x21
	TeeLocal  = 0x22
	GetGlobal = 0x23
	SetGlobal = 0x24

	I32Load    = 0x28
	I64Load    = 0x29
	F32Load    = 0x2a
	F64Load    = 0x2b
	I32Load8s  = 0x2c
	I32Load8u  = 0x2d
	I32Load16s = 0x2e
	I32Load16u = 0x2f
	I64Load8s  = 0x30
	I64Load8u  = 0x31
	I64Load16s = 0x32
	I64Load16u = 0x33
	I64Load32s = 0x34
	I64Load32u = 0x35

	I32Store   = 0x36
	I64Store   = 0x37
	F32Store   = 0x38
	F64Store   = 0x39
	I32Store8  = 0x3a
	I32Store16 = 0x3b
	I64Store8  = 0x3c
	I64Store16 = 0x3d
	I64Store32 = 0x3e

	CurrentMemory = 0x3f
	GrowMemory    = 0x40

	I32Const = 0x41
	I64Const = 0x42
	F32Const = 0x43
	F64Const = 0x44

	I32Eqz = 0x45
	I32Eq  = 0x46
	I32Ne  = 0x47
	I32LtS = 0x48
	I32LtU = 0x49
	I32GtS = 0x4a
	I32GtU = 0x4b
	I32LeS = 0x4c
	I32LeU = 0x4d
	I32GeS = 0x4e
	I32GeU = 0x4f
	I64Eqz = 0x50
	I64Eq  = 0x51
	I64Ne  = 0x52
	I64LtS = 0x53
	I64LtU = 0x54
	I64GtS = 0x55
	I64GtU = 0x56
	I64LeS = 0x57
	I64LeU = 0x58
	I64GeS = 0x59
	I64GeU = 0x5a
	F32Eq  = 0x5b
	F32Ne  = 0x5c
	F32Lt  = 0x5d
	F32Gt  = 0x5e
	F32Le  = 0x5f
	F32Ge  = 0x60
	F64Eq  = 0x61
	F64Ne  = 0x62
	F64Lt  = 0x63
	F64Gt  = 0x64
	F64Le  = 0x65
	F64Ge  = 0x66

	I32Clz      = 0x67
	I32Ctz      = 0x68
	I32Popcnt   = 0x69
	I32Add      = 0x6a
	I32Sub      = 0x6b
	I32Mul      = 0x6c
	I32DivS     = 0x6d
	I32DivU     = 0x6e
	I32RemS     = 0x6f
	I32RemU     = 0x70
	I32And      = 0x71
	I32Or       = 0x72
	I32Xor      = 0x73
	I32Shl      = 0x74
	I32ShrS     = 0x75
	I32ShrU     = 0x76
	I32Rotl     = 0x77
	I32Rotr     = 0x78
	I64Clz      = 0x79
	I64Ctz      = 0x7a
	I64Popcnt   = 0x7b
	I64Add      = 0x7c
	I64Sub      = 0x7d
	I64Mul      = 0x7e
	I64DivS     = 0x7f
	I64DivU     = 0x80
	I64RemS     = 0x81
	I64RemU     = 0x82
	I64And      = 0x83
	I64Or       = 0x84
	I64Xor      = 0x85
	I64Shl      = 0x86
	I64ShrS     = 0x87
	I64ShrU     = 0x88
	I64Rotl     = 0x89
	I64Rotr     = 0x8a
	F32Abs      = 0x8b
	F32Neg      = 0x8c
	F32Ceil     = 0x8d
	F32Floor    = 0x8e
	F32Trunc    = 0x8f
	F32Nearest  = 0x90
	F32Sqrt     = 0x91
	F32Add      = 0x92
	F32Sub      = 0x93
	F32Mul      = 0x94
	F32Div      = 0x95
	F32Min      = 0x96
	F32Max      = 0x97
	F32Copysign = 0x98
	F64Abs      = 0x99
	F64Neg      = 0x9a
	F64Ceil     = 0x9b
	F64Floor    = 0x9c
	F64Trunc    = 0x9d
	F64Nearest  = 0x9e
	F64Sqrt     = 0x9f
	F64Add      = 0xa0
	F64Sub      = 0xa1
	F64Mul      = 0xa2
	F64Div      = 0xa3
	F64Min      = 0xa4
	F64Max      = 0xa5
	F64Copysign = 0xa6

	I32WrapI64     = 0xa7
	I32TruncSF32   = 0xa8
	I32TruncUF32   = 0xa9
	I32TruncSF64   = 0xaa
	I32TruncUF64   = 0xab
	I64ExtendSI32  = 0xac
	I64ExtendUI32  = 0xad
	I64TruncSF32   = 0xae
	I64TruncUF32   = 0xaf
	I64TruncSF64   = 0xb0
	I64TruncUF64   = 0xb1
	F32ConvertSI32 = 0xb2
	F32ConvertUI32 = 0xb3
	F32ConvertSI64 = 0xb4
	F32ConvertUI64 = 0xb5
	F32DemoteF64   = 0xb6
	F64ConvertSI32 = 0xb7
	F64ConvertUI32 = 0xb8
	F64ConvertSI64 = 0xb9
	F64ConvertUI64 = 0xba
	F64PromoteF32  = 0xbb

	I32ReinterpretF32 = 0xbc
	I64ReinterpretF64 = 0xbd
	F32ReinterpretI32 = 0xbe
	F64ReinterpretI64 = 0xbf
)
View Source 
const (
	MigrateContractGas = uint64(68000)
)

Variables

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")
	ErrNoCompatibleInterpreter  = errors.New("no compatible interpreter")
	ErrAbort                    = errors.New("vm exec abort")
	ErrExecBadContract          = errors.New("exec bad contract")
	ErrUnderPrice               = errors.New("gas price is lower than minimum")
)

List evm execution errors

View Source 
var (
	EvmInterpOld = BytesToInterpType([]byte{0x60, 0x60, 0x60, 0x40}) // 60606040  Match until evm 4.2 version
	EvmInterpNew = BytesToInterpType([]byte{0x60, 0x80, 0x60, 0x40}) // 60806040  Matches after evm 4.2 version
	WasmInterp   = BytesToInterpType([]byte{0x00, 0x61, 0x73, 0x6d}) // 0061736d  Matches wasm
)
View Source 
var (
	ErrWASMWriteProtection          = errors.New("WASM: write protection")
	ErrWASMMigrate                  = errors.New("WASM: failed to migrate contract")
	ErrWASMEventCountToLarge        = errors.New("WASM: event indexed count too large")
	ErrWASMEventContentToLong       = errors.New("WASM: event indexed content too long")
	ErrWASMSha3DstToShort           = errors.New("WASM: sha3 dst len too short")
	ErrWASMPanicOp                  = errors.New("WASM: transaction err op")
	ErrWASMOldContractCodeNotExists = errors.New("WASM: old contract code is not exists")
	ErrWASMUndefinedPanic           = errors.New("WASM: vm undefined err")
	ErrWASMRlpItemCountTooLarge     = errors.New("WASM: itemCount too large for RLP")
)
View Source 
var (
	Delimiter = []byte("")
)
View Source 
var PhoenixChainPrecompiledContracts = map[common.Address]PrecompiledContract{
	vm.ValidatorInnerContractAddr: &validatorInnerContract{},

	vm.StakingContractAddr:     &StakingContract{},
	vm.RestrictingContractAddr: &RestrictingContract{},
	vm.SlashingContractAddr:    &SlashingContract{},
	vm.GovContractAddr:         &GovContract{},
	vm.RewardManagerPoolAddr:   &rewardEmpty{},
	vm.DelegateRewardPoolAddr:  &DelegateRewardContract{},
}
View Source 
var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{
	common.BytesToAddress([]byte{1}): &ecrecover{},
	common.BytesToAddress([]byte{2}): &sha256hash{},
	common.BytesToAddress([]byte{3}): &ripemd160hash{},
	common.BytesToAddress([]byte{4}): &dataCopy{},
	common.BytesToAddress([]byte{5}): &bigModExp{},
	common.BytesToAddress([]byte{6}): &bn256Add{},
	common.BytesToAddress([]byte{7}): &bn256ScalarMul{},
	common.BytesToAddress([]byte{8}): &bn256Pairing{},
	common.BytesToAddress([]byte{9}): &blake2F{},
}

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 WasmGasCostTable [255]uint64
View Source 
var WasmInstrString = map[byte]string{}/* 172 elements not displayed */

Functions

func Address 

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

define: void address(char hash[20]);

func Balance 

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

func BlockHash 

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

func BlockNumber 

func BlockNumber(proc *exec.Process) uint64

func CallContract 

func CallContract(proc *exec.Process, addrPtr, args, argsLen, val, valLen, callCost, callCostLen uint32) int32

func CallValue 

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

define: uint8_t callValue();

func Caller 

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

func CallerNonce 

func CallerNonce(proc *exec.Process) uint64

func CanUseEVMInterp 

func CanUseEVMInterp(b []byte) bool

func CanUseWASMInterp 

func CanUseWASMInterp(b []byte) bool

func Coinbase 

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

func ContractCode 

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

int32_t phoenixchain_contract_code(const uint8_t addr[20], uint8_t *code, size_t code_length);

func ContractCodeLength 

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

size_t phoenixchain_contract_code_length(const uint8_t addr[20]);

func CreateContract 

func CreateContract(proc *exec.Process, newAddr, val, valLen, callCost, callCostLen uint32, input []byte) int32

func Debug 

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

func DelegateCallContract 

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

func DestroyContract 

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

func Ecrecover 

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

func EmitEvent 

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

func Gas 

func Gas(proc *exec.Process) uint64

func GasLimit 

func GasLimit(proc *exec.Process) uint64

func GasPrice 

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

func GetCallOutput 

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

func GetCallOutputLength 

func GetCallOutputLength(proc *exec.Process) uint32

func GetInput 

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

func GetInputLength 

func GetInputLength(proc *exec.Process) uint32

func GetState 

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

func GetStateLength 

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

func IsBlank 

func IsBlank(i interface{}) bool

func IsEVMPrecompiledContract 

func IsEVMPrecompiledContract(addr common.Address) bool

func IsPhoenixChainPrecompiledContract 

func IsPhoenixChainPrecompiledContract(addr common.Address) bool

func IsPrecompiledContract 

func IsPrecompiledContract(addr common.Address) bool

func MigrateCloneContract 

func MigrateCloneContract(proc *exec.Process, oldAddr, newAddr, args, argsLen, val, valLen, callCost, callCostLen uint32) int32

func MigrateContract 

func MigrateContract(proc *exec.Process, newAddr, args, argsLen, val, valLen, callCost, callCostLen uint32) int32

func MigrateInnerContract 

func MigrateInnerContract(proc *exec.Process, newAddr, val, valLen, callCost, callCostLen uint32, input []byte) int32

func NewHostModule 

func NewHostModule() *wasm.Module

func NewWasmEngineCreator 

func NewWasmEngineCreator(vm WasmInsType) (wasmEngineCreator, error)

func Origin 

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

func Panic 

func Panic(proc *exec.Process)

func PhoenixchainClone 

func PhoenixchainClone(proc *exec.Process, oldAddr, newAddr, args, argsLen, val, valLen, callCost, callCostLen uint32) int32

int32_t phoenixchain_clone(const uint8_t old_addr[20], uint8_t newAddr[20], const uint8_t* args, size_t argsLen, const uint8_t* value, size_t valueLen, const uint8_t* callCost, size_t callCostLen);

func PhoenixchainDeploy 

func PhoenixchainDeploy(proc *exec.Process, newAddr, args, argsLen, val, valLen, callCost, callCostLen uint32) int32

int32_t phoenixchain_deploy(uint8_t newAddr[20], const uint8_t* args, size_t argsLen, const uint8_t* value, size_t valueLen, const uint8_t* callCost, size_t callCostLen);

func ReadWasmModule 

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

func ReturnContract 

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

func Revert 

func Revert(proc *exec.Process)

func Ripemd160 

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

func RlpBytes 

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

void phoenixchain_rlp_bytes(const void *data, size_t len, void * dest);

func RlpBytesSize 

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

size_t rlp_bytes_size(const void *data, size_t len);

func RlpList 

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

void phoenixchain_rlp_list(const void *data, size_t len, void * dest);

func RlpListSize 

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

size_t rlp_list_size(const void *data, size_t len);

func RlpU128 

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

void phoenixchain_rlp_u128(uint64_t heigh, uint64_t low, void * dest);

func RlpU128Size 

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

size_t rlp_u128_size(uint64_t heigh, uint64_t low);

func RunPhoenixChainPrecompiledContract 

func RunPhoenixChainPrecompiledContract(p PhoenixChainPrecompiledContract, input []byte, contract *Contract) (ret []byte, err error)

func RunPrecompiledContract 

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

RunPrecompiledContract runs and evaluates the output of a precompiled contract.

func SetState 

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

storage external function

func Sha256 

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

func Sha3 

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

define: void sha3(char *src, size_t srcLen, char *dest, size_t destLen);

func StaticCallContract 

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

func Timestamp 

func Timestamp(proc *exec.Process) int64

func Transfer 

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

func WriteLogs 

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

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

func WriteTrace 

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

WriteTrace writes a formatted trace to the given writer

Types

type AccountRef 

type AccountRef common.Address

AccountRef implements ContractRef.

Account references are used during EVM initialisation and it's primary use is to fetch addresses. Removing this object proves difficult because of the cached jump destinations which are fetched from the parent contract (i.e. the caller), which is a ContractRef.

func (AccountRef) Address 

func (ar AccountRef) Address() common.Address

Address casts AccountRef to a Address

type CallContext 

type CallContext interface {
	// Call another contract
	Call(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)
	// Take another's contract code and execute within our own context
	CallCode(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)
	// Same as CallCode except sender and value is propagated from parent to child scope
	DelegateCall(env *EVM, me ContractRef, addr common.Address, data []byte, gas *big.Int) ([]byte, error)
	// Create a new contract
	Create(env *EVM, me ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error)
}

CallContext provides a basic interface for the EVM calling conventions. The EVM depends on this context being implemented for doing subcalls and initialising new EVM contracts.

type CanTransferFunc 

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

CanTransferFunc is the signature of a transfer guard function

type Config 

type Config struct {
	// Debug enable debugging Interpreter options
	Debug bool
	// Tracer is the op code logger
	Tracer Tracer
	// NoRecursion disabled interpreter call, callcode,
	// delegate call and create
	NoRecursion bool

	// JumpTable contains the EVM instruction table. This
	// may be left uninitialised and will be set to the default table.
	JumpTable [256]*operation

	ConsoleOutput bool

	// The actual implementation type of the wasm instance
	// This option is used in the configuration or command line
	WasmType WasmInsType

	// VM execution timeout duration (unit: ms)
	VmTimeoutDuration uint64
}

Config are the configuration options for the Interpreter

type Context 

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

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

	// Block information
	Coinbase    common.Address // Provides information for COINBASE
	GasLimit    uint64         // Provides information for GASLIMIT
	BlockNumber *big.Int       // Provides information for NUMBER
	Time        *big.Int       // Provides information for TIME
	Difficulty  *big.Int       // Provides information for DIFFICULTY  (This one must not be deleted, otherwise the solidity contract will be failed)

	BlockHash common.Hash // Only, the value will be available after the current block has been sealed.

	Ctx context.Context
}

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

type Contract 

type Contract struct {
	// CallerAddress is the result of the caller which initialised this
	// contract. However when the "call method" is delegated this value
	// needs to be initialised to that of the caller's caller.
	CallerAddress common.Address

	Code     []byte
	CodeHash common.Hash
	CodeAddr *common.Address
	Input    []byte

	ABI     []byte
	ABIHash common.Hash
	ABIAddr *common.Address

	Gas uint64

	DeployContract bool
	// 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) SetCallAbi 

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

todo:

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 DelegateRewardContract 

type DelegateRewardContract struct {
	Plugin *plugin.RewardMgrPlugin

	Contract *Contract
	Evm      *EVM
	// contains filtered or unexported fields
}

func (*DelegateRewardContract) CheckGasPrice 

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

func (*DelegateRewardContract) FnSigns 

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

func (*DelegateRewardContract) RequiredGas 

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

func (*DelegateRewardContract) Run 

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

type EVM 

type EVM struct {
	// Context provides auxiliary blockchain related information
	Context
	// StateDB gives access to the underlying state
	StateDB StateDB

	SnapshotDB snapshotdb.DB
	// contains filtered or unexported fields
}

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

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

func NewEVM 

func NewEVM(ctx Context, snapshotDB snapshotdb.DB, statedb StateDB, chainConfig *configs.ChainConfig, vmConfig Config) *EVM

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

func (*EVM) Call 

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

Call executes the contract associated with the addr with the given input as parameters. It also handles any necessary value transfer required and takes the necessary steps to create accounts and reverses the state in case of an execution error or failed value transfer.

func (*EVM) CallCode 

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

CallCode executes the contract associated with the addr with the given input as parameters. It also handles any necessary value transfer required and takes the necessary steps to create accounts and reverses the state in case of an execution error or failed value transfer.

CallCode differs from Call in the sense that it executes the given address' code with the caller as context.

func (*EVM) Cancel 

func (evm *EVM) Cancel()

Cancel cancels any running EVM operation. This may be called concurrently and it's safe to be called multiple times.

func (*EVM) Cancelled 

func (evm *EVM) Cancelled() bool

Cancelled returns true if Cancel has been called

func (*EVM) ChainConfig 

func (evm *EVM) ChainConfig() *configs.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) DBSnapshot 

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

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

func (evm *EVM) GetEvm() *EVM

func (*EVM) GetStateDB 

func (evm *EVM) GetStateDB() StateDB

func (*EVM) GetVMConfig 

func (evm *EVM) GetVMConfig() Config

func (*EVM) Interpreter 

func (evm *EVM) Interpreter() Interpreter

Interpreter returns the current interpreter

func (*EVM) RevertToDBSnapshot 

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

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 GovContract 

type GovContract struct {
	Plugin   *plugin.GovPlugin
	Contract *Contract
	Evm      *EVM
}

func (*GovContract) CheckGasPrice 

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

func (*GovContract) FnSigns 

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

func (*GovContract) RequiredGas 

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

func (*GovContract) Run 

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

type InterpType 

type InterpType [InterpTypeLen]byte

vm interpreter types

func BytesToInterpType 

func BytesToInterpType(b []byte) InterpType

func (InterpType) Bytes 

func (t InterpType) Bytes() []byte

func (*InterpType) SetBytes 

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

func (InterpType) String 

func (t InterpType) String() string

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
}

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 NodeList 

type NodeList []*ValidateNode

func (*NodeList) String 

func (nl *NodeList) String() string

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 PhoenixChainPrecompiledContract 

type PhoenixChainPrecompiledContract interface {
	PrecompiledContract
	FnSigns() map[uint16]interface{} // Return PhoenixChain PrecompiledContract methods signs
	CheckGasPrice(gasPrice *big.Int, fcode uint16) error
}

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 PrecompiledContractCheck 

type PrecompiledContractCheck struct{}

func (*PrecompiledContractCheck) IsPhoenixChainPrecompiledContract 

func (pcc *PrecompiledContractCheck) IsPhoenixChainPrecompiledContract(address common.Address) bool

type ProofList 

type ProofList [][]byte

MerkleProof

func (*ProofList) Put 

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

type RestrictingContract 

type RestrictingContract struct {
	Plugin   *plugin.RestrictingPlugin
	Contract *Contract
	Evm      *EVM
}

func (*RestrictingContract) CheckGasPrice 

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

func (*RestrictingContract) FnSigns 

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

func (*RestrictingContract) RequiredGas 

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

func (*RestrictingContract) Run 

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

type ReturnStack 

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

ReturnStack is an object for basic return stack operations.

type SlashingContract 

type SlashingContract struct {
	Plugin   *plugin.SlashingPlugin
	Contract *Contract
	Evm      *EVM
}

func (*SlashingContract) CheckGasPrice 

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

func (*SlashingContract) FnSigns 

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

func (*SlashingContract) RequiredGas 

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

func (*SlashingContract) Run 

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

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 StakingContract 

type StakingContract struct {
	Plugin   *plugin.StakingPlugin
	Contract *Contract
	Evm      *EVM
}

func (*StakingContract) CheckGasPrice 

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

func (*StakingContract) FnSigns 

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

func (*StakingContract) RequiredGas 

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

func (*StakingContract) Run 

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

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

	// todo: hash -> bytes
	GetCommittedState(common.Address, []byte) []byte
	//GetState(common.Address, common.Hash) common.Hash
	//SetState(common.Address, common.Hash, common.Hash)
	GetState(common.Address, []byte) []byte
	SetState(common.Address, []byte, []byte)

	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)
	GetLogs(hash common.Hash) []*types.Log
	AddPreimage(common.Hash, []byte)

	ForEachStorage(common.Address, func([]byte, []byte) bool)
	MigrateStorage(from, to common.Address)
	//dpos add
	TxHash() common.Hash
	TxIdx() uint32

	IntermediateRoot(deleteEmptyObjects bool) common.Hash

	GetCurrentActiveVersion() uint32
}

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 VMContext 

type VMContext struct {
	Input   []byte
	CallOut []byte
	Output  []byte

	Revert bool
	Log    *WasmLogger
	// contains filtered or unexported fields
}

type ValidateNode 

type ValidateNode struct {
	Index     uint               `json:"index"`
	NodeID    discover.NodeID    `json:"nodeID"`
	Address   common.NodeAddress `json:"-"`
	BlsPubKey bls.PublicKey      `json:"blsPubKey"`
}

type ValidatorInnerContractBase 

type ValidatorInnerContractBase interface {
	UpdateValidators(validators *Validators) error
	CurrentValidators() (*Validators, error)
	NextValidators() (*Validators, error)
	SwitchValidators(validBlockNumber uint64) error
}

type Validators 

type Validators struct {
	ValidateNodes    NodeList `json:"validateNodes"`
	ValidBlockNumber uint64   `json:"-"`
}

func (*Validators) String 

func (vds *Validators) String() string

type WASMInterpreter 

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

WASMInterpreter represents an WASM interpreter

func NewWASMInterpreter 

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

NewWASMInterpreter returns a new instance of the Interpreter

func (*WASMInterpreter) CanRun 

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

CanRun tells if the contract, passed as an argument, can be run by the current interpreter

func (*WASMInterpreter) Run 

func (in *WASMInterpreter) 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 operations except for ErrExecutionReverted which means revert-and-keep-gas-lfet.

type WasmDeploy 

type WasmDeploy struct {
	VM   byte
	Args [][]byte
}

type WasmInoke 

type WasmInoke struct {
	VM   byte
	Args *WasmParams
}

type WasmInsType 

type WasmInsType byte
const (
	Unknown WasmInsType = 0x00
	Wagon   WasmInsType = 0x01
)

func Str2WasmType 

func Str2WasmType(str string) WasmInsType

func (WasmInsType) String 

func (t WasmInsType) String() string

type WasmLogger 

type WasmLogger struct {
	log.Logger
	// contains filtered or unexported fields
}

func NewWasmLogger 

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

func (*WasmLogger) Crit 

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

func (*WasmLogger) Debug 

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

func (*WasmLogger) Error 

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

func (*WasmLogger) Flush 

func (wl *WasmLogger) Flush()

func (*WasmLogger) GetHandler 

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

GetHandler gets the handler associated with the logger.

func (*WasmLogger) Info 

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

func (*WasmLogger) New 

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

func (*WasmLogger) SetHandler 

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

SetHandler updates the logger to write records to the specified handler.

func (*WasmLogger) Trace 

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

Log a message at the given level with context key/value pairs

func (*WasmLogger) Warn 

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

type WasmParams 

type WasmParams struct {
	FuncName []byte
	Args     [][]byte
}

Source Files

View all Source files

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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.