vm

package
v0.0.0-...-ac8b7ce Latest Latest
Warning

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

 Go to latest Published: Jan 27, 2021 License: GPL-3.0 Imports: 18 Imported by: 22

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.

Copyright 2015 The github.com/blockchain-analysis-study/go-ethereum-analysis Authors This file is part of the github.com/blockchain-analysis-study/go-ethereum-analysis library.

The github.com/blockchain-analysis-study/go-ethereum-analysis library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

The github.com/blockchain-analysis-study/go-ethereum-analysis library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with the github.com/blockchain-analysis-study/go-ethereum-analysis library. If not, see <http://www.gnu.org/licenses/>. * todo 绝大部分的操作码对应的实现都在这里

* 定义了operation，就是将opcode和gas计算函数、具体实现函数等关联起来

Index

Constants

View Source 
const (
	// 一些gas成本级别
	GasQuickStep   uint64 = 2  // 基础级
	GasFastestStep uint64 = 3  // 超低级
	GasFastStep    uint64 = 5  // 低级
	GasMidStep     uint64 = 8  //
	GasSlowStep    uint64 = 10 // 高级
	GasExtStep     uint64 = 20

	GasReturn       uint64 = 0
	GasStop         uint64 = 0
	GasContractByte uint64 = 200
)

Gas costs

Variables

View Source 
var (
	// gas 不足
	ErrOutOfGas = errors.New("out of gas")
	// 部署合约时 code 消耗的gas 太多
	ErrCodeStoreOutOfGas = errors.New("contract creation code storage out of gas")
	// 超过最大通话深度
	ErrDepth = errors.New("max call depth exceeded")
	// 日志数达到指定限制
	ErrTraceLimitReached = errors.New("the number of logs reached the specified limit")
	// 余额不足，无法转移
	ErrInsufficientBalance = errors.New("insufficient balance for transfer")
	// 合约地址冲突
	ErrContractAddressCollision = errors.New("contract address collision")
	// 没有兼容的 执行器
	ErrNoCompatibleInterpreter = errors.New("no compatible interpreter")
)

List execution errors

合约执行的err

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{},
}

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.

Functions

func NoopCanTransfer 

func NoopCanTransfer(db StateDB, from common.Address, balance *big.Int) bool

func NoopTransfer 

func NoopTransfer(db StateDB, from, to common.Address, amount *big.Int)

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.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 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 enabled debugging Interpreter options
	//
	// 这是调试的标识
	Debug bool
	// Tracer is the op code logger
	//
	// 指令码的日志
	Tracer Tracer
	// NoRecursion disabled Interpreter call, callcode,
	// delegate call and create.
	//
	/**
	Config是解释器的配置选项
	NoRecursion 禁用的解释器的 Call ，Callcode， DelegateCall和 Create
	*/
	NoRecursion bool

	// Enable recording of SHA3/keccak preimages
	// 启用记录SHA3 / keccak原像
	// 1.8.x 已经废弃
	EnablePreimageRecording bool
	// JumpTable contains the EVM instruction table. This
	// may be left uninitialised and will be set to the default
	// table.
	//
	// JumpTable包含EVM指令表。 可以不进行初始化，并将其设置为默认表.
	JumpTable [256]operation
}

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
	//
	//  检查 账户的balance是否足够的回调Fn
	CanTransfer CanTransferFunc
	// Transfer transfers ether from one account to the other
	//
	// 执行转账的回调Fn
	Transfer TransferFunc
	// GetHash returns the hash corresponding to n
	// 根据相应的n <BlockNumber> 返回对应的Hash
	GetHash GetHashFunc

	// todo 实际上这个就是 msg.from (tx.from)
	Origin common.Address // Provides information for ORIGIN
	// 提供 GASPRICE `gasPrice` 信息
	GasPrice *big.Int // Provides information for GASPRICE

	// 矿工信息
	Coinbase common.Address // Provides information for COINBASE

	// 当前 Block 的GasLimit
	GasLimit uint64 // Provides information for GASLIMIT

	// 当前 Block 的 Number
	BlockNumber *big.Int // Provides information for NUMBER

	// 当前 Block 的 timestamp
	Time *big.Int // Provides information for TIME

	// 当前 Block 的 难度
	Difficulty *big.Int // Provides information for DIFFICULTY
}

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是调用方初始化此 contract 的结果。 但是，在委托调用“调用方法”时，需要将此值初始化为调用方的调用方的addr。
	普通调用:
	A -> B, 则该值为 A

	委托调用:
	A -> B -> C, 则该值为 A
	*/
	CallerAddress common.Address

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

	Gas uint64

	Args []byte

	// todo 标识 当前调用是否是 代理调用， true 是
	DelegateCall bool
	// contains filtered or unexported fields
}

Contract represents an ethereum 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) *Contract

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

NewContract: 返回用于执行EVM的新 contract环境

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

func (c *Contract) SetCode(hash common.Hash, code []byte)

SetCode sets the code to the contract

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 {
	Address() common.Address
}

ContractRef is a reference to the contract's backing object

type EVM 

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

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

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

func NewEVM 

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

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

func (*EVM) Call 

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. * todo 这个是正常的 call 调用合约 

但是如果是合约调合约的call， 那么也会进来

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. * todo 注意了， CallCode 其实只会改变发起方的 state

todo 说白了这个就是用来 使用： 被调用方的 code 来修改 发起方的值

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) 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 *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)

Create2 creates a new contract using code as deployment code.

The different between Create2 with Create is Create2 uses sha3(0xff ++ msg.sender ++ salt ++ sha3(init_code))[12:] instead of the usual sender-and-nonce-hash as the address where the contract is initialized at. * + + + todo Create2与Create2之间的区别在于 + + todo Create2使用sha3（0xff ++ msg.sender ++盐++ sha3（init_code））[12：]代替了通常的 sender + nonce 作为初始化合同的地址的方式. +

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. * todo 委托调用合约

todo 说白了这个就是用来 使用： 被调用方的 code 来修改 发起方的值

func (*EVM) Interpreter 

func (evm *EVM) Interpreter() Interpreter

Interpreter returns the current interpreter

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. todo 静态调用

todo STATICCALL是CALL的新变体，它仅允许对其他合同（包括其本身）进行无状态更改的调用

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

func (in *EVMInterpreter) IsReadOnly() bool

IsReadOnly reports if the interpreter is in read only mode.

func (*EVMInterpreter) Run 

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

* 执行 EVM

func (*EVMInterpreter) SetReadOnly 

func (in *EVMInterpreter) SetReadOnly(ro bool)

SetReadOnly sets (or unsets) read only mode in the interpreter.

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 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) ([]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
	// IsReadOnly reports if the interpreter is in read only mode.
	IsReadOnly() bool
	// SetReadOnly sets (or unsets) read only mode in the interpreter.
	SetReadOnly(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 LogConfig 

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

LogConfig are the configuration options for structured logger the EVM

type Memory 

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

Memory implements a simple memory model for the ethereum virtual machine. * 自定义一个简单的 内存结构 evm的内存结构

func NewMemory 

func NewMemory() *Memory

NewMemory returns a new memory memory model.

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

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

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

type NoopEVMCallContext 

type NoopEVMCallContext struct{}

func (NoopEVMCallContext) Call 

func (NoopEVMCallContext) Call(caller ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)

func (NoopEVMCallContext) CallCode 

func (NoopEVMCallContext) CallCode(caller ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)

func (NoopEVMCallContext) Create 

func (NoopEVMCallContext) Create(caller ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error)

func (NoopEVMCallContext) DelegateCall 

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

type NoopStateDB 

type NoopStateDB struct{}

func (NoopStateDB) AddBalance 

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

func (NoopStateDB) AddLog 

func (NoopStateDB) AddLog(*types.Log)

func (NoopStateDB) AddPreimage 

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

func (NoopStateDB) AddRefund 

func (NoopStateDB) AddRefund(uint64)

func (NoopStateDB) CreateAccount 

func (NoopStateDB) CreateAccount(common.Address)

func (NoopStateDB) Empty 

func (NoopStateDB) Empty(common.Address) bool

func (NoopStateDB) Exist 

func (NoopStateDB) Exist(common.Address) bool

func (NoopStateDB) ForEachStorage 

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

func (NoopStateDB) GetBalance 

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

func (NoopStateDB) GetCode 

func (NoopStateDB) GetCode(common.Address) []byte

func (NoopStateDB) GetCodeHash 

func (NoopStateDB) GetCodeHash(common.Address) common.Hash

func (NoopStateDB) GetCodeSize 

func (NoopStateDB) GetCodeSize(common.Address) int

func (NoopStateDB) GetNonce 

func (NoopStateDB) GetNonce(common.Address) uint64

func (NoopStateDB) GetRefund 

func (NoopStateDB) GetRefund() uint64

func (NoopStateDB) GetState 

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

func (NoopStateDB) HasSuicided 

func (NoopStateDB) HasSuicided(common.Address) bool

func (NoopStateDB) RevertToSnapshot 

func (NoopStateDB) RevertToSnapshot(int)

func (NoopStateDB) SetCode 

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

func (NoopStateDB) SetNonce 

func (NoopStateDB) SetNonce(common.Address, uint64)

func (NoopStateDB) SetState 

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

func (NoopStateDB) Snapshot 

func (NoopStateDB) Snapshot() int

func (NoopStateDB) SubBalance 

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

func (NoopStateDB) Suicide 

func (NoopStateDB) Suicide(common.Address) bool

type OpCode 

type OpCode byte

OpCode is an EVM opcode 定义EVM的执行码 

const (
	STOP       OpCode = iota // 0 == 0x00
	ADD                      // 1 == 0x01
	MUL                      // 2
	SUB                      // 3
	DIV                      // 4
	SDIV                     // 5
	MOD                      // 6
	SMOD                     // 7
	ADDMOD                   // 8
	MULMOD                   // 9
	EXP                      // 10  == 0x0a
	SIGNEXTEND               // 11  == 0x0b
)

0x0 range - arithmetic ops. 

const (
	LT     OpCode = iota + 0x10 // 0x10 == 16
	GT                          // 0x11 == 17
	SLT                         // 0x12
	SGT                         // 0x13
	EQ                          // 0x14
	ISZERO                      // 0x15
	AND                         // 0x16
	OR                          // 0x17
	XOR                         // 0x18
	NOT                         // 0x19
	BYTE                        // 0x1a	== 26
	SHL                         // 0x1b
	SHR                         // 0x1c
	SAR                         // 0x1d == 29

	SHA3 = 0x20 // 32
)

0x10 range - comparison ops. 

const (
	ADDRESS        OpCode = 0x30 + iota // 0x30 == 48
	BALANCE                             // 0x31 == 49
	ORIGIN                              // 0x32
	CALLER                              // 0x33
	CALLVALUE                           // 0x34
	CALLDATALOAD                        // 0x35
	CALLDATASIZE                        // 0x36
	CALLDATACOPY                        // 0x37
	CODESIZE                            // 0x38
	CODECOPY                            // 0x39
	GASPRICE                            // 0x3a == 58
	EXTCODESIZE                         // 0x3b
	EXTCODECOPY                         // 0x3c
	RETURNDATASIZE                      // 0x3d
	RETURNDATACOPY                      // 0x3e
	EXTCODEHASH                         // 0x3f == 63
)

0x30 range - closure state. 

const (
	BLOCKHASH  OpCode = 0x40 + iota // 0x40 == 64
	COINBASE                        // 0x41
	TIMESTAMP                       // 0x42
	NUMBER                          // 0x43
	DIFFICULTY                      // 0x44
	GASLIMIT                        // 0x45 == 69
)

0x40 range - block operations. 

const (
	POP      OpCode = 0x50 + iota // 0x50 == 80
	MLOAD                         // 0x51
	MSTORE                        // 0x52
	MSTORE8                       // 0x53
	SLOAD                         // 0x54
	SSTORE                        // 0x55
	JUMP                          // 0x56
	JUMPI                         // 0x57
	PC                            // 0x58
	MSIZE                         // 0x59
	GAS                           // 0x5a == 90
	JUMPDEST                      // 0x5b == 91
)

0x50 range - 'storage' and execution. 

const (
	PUSH1  OpCode = 0x60 + iota // 0x60 == 96
	PUSH2                       // 0x61
	PUSH3                       // 0x62
	PUSH4                       // 0x63
	PUSH5                       // 0x64
	PUSH6                       // 0x65
	PUSH7                       // 0x66
	PUSH8                       // 0x67
	PUSH9                       // 0x68
	PUSH10                      // 0x69
	PUSH11                      // 0x6a == 106
	PUSH12                      // 0x6b
	PUSH13                      // 0x6c
	PUSH14                      // 0x6d
	PUSH15                      // 0x6e
	PUSH16                      // 0x6f
	PUSH17                      // 0x70 == 112
	PUSH18                      // 0x71
	PUSH19                      // 0x72
	PUSH20                      // 0x73
	PUSH21                      // 0x74
	PUSH22                      // 0x75
	PUSH23                      // 0x76
	PUSH24                      // 0x77
	PUSH25                      // 0x78
	PUSH26                      // 0x79
	PUSH27                      // 0x7a == 122
	PUSH28                      // 0x7b
	PUSH29                      // 0x7c
	PUSH30                      // 0x7d
	PUSH31                      // 0x7e
	PUSH32                      // 0x7f
	DUP1                        // 0x80 == 128
	DUP2                        // 0x81
	DUP3                        // 0x82
	DUP4                        // 0x83
	DUP5                        // 0x84
	DUP6                        // 0x85
	DUP7                        // 0x86
	DUP8                        // 0x87
	DUP9                        // 0x88
	DUP10                       // 0x89
	DUP11                       // 0x8a == 138
	DUP12                       // 0x8b
	DUP13                       // 0x8c
	DUP14                       // 0x8d
	DUP15                       // 0x8e
	DUP16                       // 0x8f
	SWAP1                       // 0x90 == 144
	SWAP2                       // 0x91
	SWAP3                       // 0x92
	SWAP4                       // 0x93
	SWAP5                       // 0x94
	SWAP6                       // 0x95
	SWAP7                       // 0x96
	SWAP8                       // 0x97
	SWAP9                       // 0x98
	SWAP10                      // 0x99
	SWAP11                      // 0x9a == 154
	SWAP12                      // 0x9b
	SWAP13                      // 0x9c
	SWAP14                      // 0x9d
	SWAP15                      // 0x9e
	SWAP16                      // 0x9f == 159
)

0x60 range. 

const (
	LOG0 OpCode = 0xa0 + iota // 0xa0 == 160
	LOG1                      // 0xa1 == 161
	LOG2                      // 0xa2
	LOG3                      // 0xa3
	LOG4                      // 0xa4 == 164
)

0xa0 range - logging ops. 

const (
	PUSH OpCode = 0xb0 + iota // 0xb0 == 176
	DUP                       // 0xb1
	SWAP                      // 0xb2 == 178
)

unofficial opcodes used for parsing. 

const (
	CREATE       OpCode = 0xf0 + iota // 0xf0 == 15 * 16 == 240
	CALL                              // 0xf1  这个一个执行码对应的 execute 中会再次调用EVM.Call() 函数，使得Call函数形成 【间接递归】
	CALLCODE                          // 0xf2
	RETURN                            // 0xf3
	DELEGATECALL                      // 0xf4
	CREATE2                           // 0xf5
	STATICCALL   = 0xfa               // 0xfa == 250

	REVERT       = 0xfd // 0xfd	== 253
	SELFDESTRUCT = 0xff // 0xff	== 255
)

0xf0 range - closures. 取值为 0xf0 - 0xff

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. 判断当前执行码是否 push操作的执行码

func (OpCode) IsStaticJump 

func (op OpCode) IsStaticJump() bool

IsStaticJump specifies if an opcode is JUMP. 判断是否是 jump 操作的执行码

func (OpCode) String 

func (op 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. * 自定义 栈结构体 evm所需要的栈

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

Data returns the underlying big.Int array.

func (*Stack) Print 

func (st *Stack) Print()

Print dumps the content of the stack

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)
	GetRefund() uint64

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

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

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

	RevertToSnapshot(int)
	Snapshot() int

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

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

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"`
	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

ErrorString formats the log's error as a string.

func (StructLog) MarshalJSON 

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

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

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, 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, 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. * todo CaptureState: 记录新的结构化日志消息并将其推送到环境

todo CaptureState: 还跟踪SSTORE操作以跟踪 脏值 <最近变动的值>。

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

type TransferFunc 

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

TransferFunc is the signature of a transfer function

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.