vm

package
v0.0.0-...-471f645 Latest Latest
Warning

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

Go to latest
Published: Oct 25, 2021 License: GPL-3.0 Imports: 26 Imported by: 0

Documentation

Overview

VM is a Virtual Machine based on Ethereum Virtual Machine

Index

Constants

View Source
const (
	GasQuickStep    uint64 = 2
	GasFastestStep  uint64 = 3
	GasFastStep     uint64 = 5
	GasMidStep      uint64 = 8
	GasSlowStep     uint64 = 0
	GasExtStep      uint64 = 0
	GasReturn       uint64 = 0
	GasStop         uint64 = 0
	GasContractByte uint64 = 200
)
View Source
const (
	//0xc0 range  new add for multi-asset
	ISSUEASSET    OpCode = 0xc0 + iota
	ADDASSET             = 0xc1
	SETASSETOWNER        = 0xc2
	BALANCEEX            = 0xc3
	CALLEX               = 0xc4
	ASSETINFO            = 0xc5
	//snapshot num
	SNAPSHOTTIME = 0xc6
	SNAPBALANCE  = 0xc7
	//
	DESTROYASSET = 0xc8
	GETACCOUNTID = 0xc9

	GETACCOUNTTIME = 0xcb
	CRYPTOCALC     = 0xcc
	DEDUCTGAS      = 0xcd
	WITHDRAWFEE    = 0xce
	GETASSETID     = 0xcf
)
View Source
const (
	//0xd0 range  new add for dpos
	GETEPCHO        OpCode = 0xd0 + iota
	GETCANDIDATENUM        = 0xd1
	GETCANDIDATE           = 0xd2
	GETVOTERSTAKE          = 0xd3
	RECIPIENT              = 0xd4

	CALLWITHPAY = 0xd5
	EXTCOUNT    = 0xd6
)
View Source
const (
	// 0xf0 range - closures
	CREATE OpCode = 0xf0 + iota
	CALL
	CALLCODE
	RETURN
	DELEGATECALL
	STATICCALL = 0xfa

	REVERT = 0xfd
	///< invalid instruction for expressing runtime errors (e.g., division-by-zero)
	INVALID      = 0xfe
	SELFDESTRUCT = 0xff
)

Variables

View Source
var (
	ErrOutOfGas                 = errors.New("out of gas")
	ErrCodeStoreOutOfGas        = errors.New("contract creation code storage out of gas")
	ErrDepth                    = errors.New("max call depth exceeded")
	ErrTraceLimitReached        = errors.New("the number of logs reached the specified limit")
	ErrInsufficientBalance      = errors.New("insufficient balance for transfer")
	ErrContractAddressCollision = errors.New("contract name collision")
	ErrContractCodeCollision    = errors.New("contract code collision")
	ErrAccountNotExist          = errors.New("account not exist")
	ErrExecOverTime             = errors.New("vm exec overtime shutdown")
)
View Source
var PrecompiledContracts = map[uint64]PrecompiledContract{
	1: &ecrecover{},
	2: &sha256hash{},
	3: &ripemd160hash{},
	4: &dataCopy{},
	5: &bigModExp{},
	6: &bn256Add{},
	7: &bn256ScalarMul{},
	8: &bn256Pairing{},
}

PrecompiledContracts contains the default set of pre-compiled

Functions

func NewByzantiumInstructionSet

func NewByzantiumInstructionSet() [256]operation

NewByzantiumInstructionSet returns the frontier, homestead and byzantium instructions.

func NewConstantinopleInstructionSet

func NewConstantinopleInstructionSet() [256]operation

NewConstantinopleInstructionSet returns the frontier, homestead byzantium and contantinople instructions.

func NewFrontierInstructionSet

func NewFrontierInstructionSet() [256]operation

NewFrontierInstructionSet returns the frontier instructions that can be executed during the frontier phase.

func NewHomesteadInstructionSet

func NewHomesteadInstructionSet() [256]operation

NewHomesteadInstructionSet returns the frontier and homestead instructions that can be executed during the homestead phase.

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 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.Name

AccountRef implements ContractRef.

Account references are used during EVM initialisation and it's primary use is to fetch names. 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) Name

func (ar AccountRef) Name() common.Name

Name casts AccountRef to a Name

type Config

type Config struct {
	// Debug enabled debugging Interpreter options
	Debug bool
	// EnableJit enabled the JIT VM
	EnableJit bool
	// ForceJit forces the JIT VM
	ForceJit bool
	// Tracer is the op code logger
	Tracer Tracer
	// NoRecursion disabled Interpreter call, callcode,
	// delegate call and create.
	NoRecursion bool
	// Disable gas metering
	DisableGasMetering bool
	// Enable recording of SHA3/keccak preimages
	EnablePreimageRecording bool
	// JumpTable contains the EVM instruction table. This
	// may be left uninitialised and will be set to the default
	// table.
	JumpTable       [256]operation
	ContractLogFlag bool
	//
	EndTime time.Time
}

Config are the configuration options for the Interpreter

type Context

type Context struct {
	GetHash            GetHashFunc
	GetDelegatedByTime GetDelegatedByTimeFunc
	//GetLatestEpoch          GetLatestEpochFunc
	//GetPrevEpoch            GetPrevEpochFunc
	GetEpoch                GetEpochFunc
	GetActivedCandidateSize GetActivedCandidateSizeFunc
	GetActivedCandidate     GetActivedCandidateFunc
	GetVoterStake           GetVoterStakeFunc
	GetHeaderByNumber       GetHeaderByNumberFunc

	// Message information
	Origin    common.Name // Provides information for ORIGIN
	Recipient common.Name
	From      common.Name // Provides information for ORIGIN
	AssetID   uint64      // provides assetId
	GasPrice  *big.Int    // Provides information for GASPRICE

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

	// Asset information
	ExAssetIDs []uint64
	ExValues   []*big.Int
}

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

type Contract

type Contract struct {
	// CallerName 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.
	CallerName common.Name

	Code     []byte
	CodeHash common.Hash
	CodeName *common.Name
	Input    []byte

	Gas uint64

	AssetID uint64

	Args []byte

	DelegateCall bool
	// contains filtered or unexported fields
}

Contract represents an contract in the state database. It contains the the contract code, calling arguments. Contract implements ContractRef

func NewContract

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

NewContract returns a new contract environment for the execution of EVM.

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.Name

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

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

Name returns the contracts name

func (*Contract) SetCallCode

func (c *Contract) SetCallCode(name *common.Name, hash common.Hash, code []byte)

SetCallCode sets the code of the contract and name of the backing dataobject

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 contracts value (sent to it from it's caller)

type ContractRef

type ContractRef interface {
	Name() common.Name
}

ContractRef is a reference to the contract's backing object

type DistributeGas

type DistributeGas struct {
	Value  int64
	TypeID uint64
}

type DistributeKey

type DistributeKey struct {
	ObjectName common.Name
	ObjectType uint64
}

type DistributeKeys

type DistributeKeys []DistributeKey

func (DistributeKeys) Len

func (keys DistributeKeys) Len() int

func (DistributeKeys) Less

func (keys DistributeKeys) Less(i, j int) bool

func (DistributeKeys) Swap

func (keys DistributeKeys) Swap(i, j int)

type EVM

type EVM struct {
	// Context provides auxiliary blockchain related information
	Context
	// Asset operation func
	AccountDB *accountmanager.AccountManager
	// StateDB gives access to the underlying state
	StateDB *state.StateDB

	FounderGasMap map[DistributeKey]DistributeGas

	InternalTxs []*types.InternalAction
	// contains filtered or unexported fields
}

func NewEVM

func NewEVM(ctx Context, accountdb *accountmanager.AccountManager, statedb *state.StateDB, chainCfg *params.ChainConfig, vmConfig Config) *EVM

NewEVM retutrns 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, action *types.Action, gas uint64) (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, action *types.Action, gas uint64) (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) CanTransferContractAsset

func (evm *EVM) CanTransferContractAsset(caller ContractRef, gas uint64, assetID uint64, assetContract common.Name) (uint64, bool)

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

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

ChainConfig returns the environment's chain configuration

func (*EVM) CheckReceipt

func (evm *EVM) CheckReceipt(action *types.Action) uint64

func (*EVM) Create

func (evm *EVM) Create(caller ContractRef, action *types.Action, gas uint64) (ret []byte, leftOverGas uint64, err error)

Create creates a new contract using code as deployment code.

func (*EVM) DelegateCall

func (evm *EVM) DelegateCall(caller ContractRef, name common.Name, 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) GetCurrentGasTable

func (evm *EVM) GetCurrentGasTable() params.GasTable

func (*EVM) Interpreter

func (evm *EVM) Interpreter() *Interpreter

Interpreter returns the EVM interpreter

func (*EVM) IsOverTime

func (evm *EVM) IsOverTime() bool

Check vm is overtime abort

func (*EVM) OverTimeAbort

func (evm *EVM) OverTimeAbort()

func (*EVM) StaticCall

func (evm *EVM) StaticCall(caller ContractRef, name common.Name, 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 FounderGas

type FounderGas struct {
	Founder common.Name
	Gas     uint64
}

type GetActivedCandidateFunc

type GetActivedCandidateFunc func(state *state.StateDB, epoch uint64, index uint64) (name string, stake *big.Int, votes *big.Int, counter uint64, actualCounter uint64, replace uint64, isbad bool, err error)

GetActivedCandidate

type GetActivedCandidateSizeFunc

type GetActivedCandidateSizeFunc func(state *state.StateDB, epoch uint64) (size uint64, err error)

GetActivedCandidateSize

type GetDelegatedByTimeFunc

type GetDelegatedByTimeFunc func(*state.StateDB, string, uint64) (stake *big.Int, err error)

GetDelegatedByTimeFunc returns the delegated balance

type GetEpochFunc

type GetEpochFunc func(state *state.StateDB, t uint64, curEpoch uint64) (epoch uint64, time uint64, err error)

GetEpoch

type GetHashFunc

type GetHashFunc func(uint64) common.Hash

GetHashFunc returns the nth block hash in the blockchain and is used by the BLOCKHASH EVM op code.

type GetHeaderByNumberFunc

type GetHeaderByNumberFunc func(number uint64) *types.Header

GetHeaderByNumberFunc

type GetVoterStakeFunc

type GetVoterStakeFunc func(state *state.StateDB, epoch uint64, voter string, candidate string) (stake *big.Int, err error)

GetVoterStake

type Interpreter

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

Interpreter is used to run based contracts and will utilise the passed evmironment to query external sources for state information. The Interpreter will run the byte code VM or JIT VM based on the passed configuration.

func NewInterpreter

func NewInterpreter(evm *EVM, cfg Config) *Interpreter

NewInterpreter returns a new instance of the Interpreter.

func (*Interpreter) GetGasTable

func (in *Interpreter) GetGasTable() params.GasTable

func (*Interpreter) Run

func (in *Interpreter) Run(contract *Contract, input []byte) (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 LogConfig

type LogConfig struct {
	DisableMemory  bool // disable memory capture
	DisableStack   bool // disable stack capture
	DisableStorage bool // disable storage capture
	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 virtual machine.

func NewMemory

func NewMemory() *Memory

func (*Memory) Data

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

Data returns the backing slice

func (*Memory) Get

func (m *Memory) Get(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()

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

type OpCode

type OpCode byte

OpCode is an EVM opcode

const (
	// 0x0 range - arithmetic ops
	STOP OpCode = iota
	ADD
	MUL
	SUB
	DIV
	SDIV
	MOD
	SMOD
	ADDMOD
	MULMOD
	EXP
	SIGNEXTEND
)
const (
	LT OpCode = iota + 0x10
	GT
	SLT
	SGT
	EQ
	ISZERO
	AND
	OR
	XOR
	NOT
	BYTE
	SHL
	SHR
	SAR

	SHA3 = 0x20
)
const (
	// 0x30 range - closure state
	ADDRESS OpCode = 0x30 + iota
	BALANCE
	ORIGIN
	CALLER
	CALLVALUE
	CALLDATALOAD
	CALLDATASIZE
	CALLDATACOPY
	CODESIZE
	CODECOPY
	GASPRICE
	EXTCODESIZE
	EXTCODECOPY
	RETURNDATASIZE
	RETURNDATACOPY
)
const (
	// 0x40 range - block operations
	BLOCKHASH OpCode = 0x40 + iota
	COINBASE
	TIMESTAMP
	NUMBER
	DIFFICULTY
	GASLIMIT
	CALLASSETID
)
const (
	// 0x50 range - 'storage' and execution
	POP OpCode = 0x50 + iota
	MLOAD
	MSTORE
	MSTORE8
	SLOAD
	SSTORE
	JUMP
	JUMPI
	PC
	MSIZE
	GAS
	JUMPDEST
)
const (
	// 0x60 range
	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
)
const (
	LOG0 OpCode = 0xa0 + iota
	LOG1
	LOG2
	LOG3
	LOG4
)
const (
	PUSH OpCode = 0xb0 + iota
	DUP
	SWAP
)

unofficial opcodes used for parsing

const (
	// 0xe0 range new add for ext assets
	EXTASSETID1 OpCode = 0xe0 + iota
	EXTVALUE1
	EXTASSETID2
	EXTVALUE2
	EXTASSETID3
	EXTVALUE3
	EXTASSETID4
	EXTVALUE4
	EXTASSETID5
	EXTVALUE5
	EXTASSETID6
	EXTVALUE6
	EXTASSETID7
	EXTVALUE7
	EXTASSETID8
	EXTVALUE8
)

func StringToOp

func StringToOp(str string) OpCode

func (OpCode) IsPush

func (op OpCode) IsPush() bool

func (OpCode) IsStaticJump

func (op OpCode) IsStaticJump() bool

func (OpCode) String

func (o OpCode) String() string

type PrecompiledContract

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

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

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

Back returns the n'th item in stack

func (*Stack) Data

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

func (*Stack) DebugPrint

func (st *Stack) DebugPrint()

func (*Stack) Print

func (st *Stack) Print()

type Storage

type Storage map[common.Hash]common.Hash

func (Storage) Copy

func (s Storage) Copy() 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"`
	Storage    map[common.Hash]common.Hash `json:"-"`
	Depth      int                         `json:"depth"`
	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

func (*StructLog) OpName

func (s *StructLog) OpName() string

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

func (*StructLogger) CaptureFault

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

func (*StructLogger) CaptureStart

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

func (*StructLogger) CaptureState

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

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

CaptureState also tracks SSTORE ops to track dirty values.

func (*StructLogger) Error

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.Name, to common.Name, call bool, input []byte, gas uint64, value *big.Int) error
	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
	CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error
}

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

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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