vm

package
v1.0.3 Latest Latest
Warning

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

 Go to latest Published: Sep 26, 2024 License: GPL-3.0 Imports: 30 Imported by: 4

Documentation

Overview

Package vm implements the Ethereum Virtual Machine.

The vm package implements one EVM, a byte code VM. The Byte Code VM loops over a set of bytes and executes them according to the set of rules defined in the Ethereum yellow paper.

As well as the original functionality of the EVM, this package implemented additional pre-compiled contracts to support the native features of Kaia. For more information about pre-compiled contracts, see docs (https://docs.kaia.io/docs/learn/computation/precompiled-contracts/).

Index

Constants

View Source 
const (
	CancelByCtxDone = 1 << iota
	CancelByTotalTimeLimit
)
View Source 
const (
	GasZero        uint64 = 0  // G_zero
	GasQuickStep   uint64 = 2  // G_base
	GasFastestStep uint64 = 3  // G_verylow
	GasFastStep    uint64 = 5  // G_low
	GasMidStep     uint64 = 8  // G_mid
	GasSlowStep    uint64 = 10 // G_high or G_exp
	GasExtStep     uint64 = 20 // G_blockhash
)

Gas costs

Variables

View Source 
var (
	PrecompiledAddressCancun      []common.Address
	PrecompiledAddressIstanbul    []common.Address
	PrecompiledAddressesByzantium []common.Address
)
View Source 
var (
	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")
	ErrTotalTimeLimitReached             = errors.New("reached the total execution time limit for txs in a block")
	ErrOpcodeComputationCostLimitReached = errors.New("reached the opcode computation cost limit")
	ErrFailedOnSetCode                   = errors.New("failed on setting code to an account")

	// EVM internal errors
	ErrWriteProtection       = errors.New("evm: write protection")
	ErrReturnDataOutOfBounds = errors.New("evm: return data out of bounds")
	ErrExecutionReverted     = errors.New("evm: execution reverted")
	ErrMaxCodeSizeExceeded   = errors.New("evm: max code size exceeded")
	ErrInvalidJump           = errors.New("evm: invalid jump destination")
	ErrInvalidCode           = errors.New("invalid code: must not begin with 0xef")
)

List execution errors

View Source 
var (
	ConstantinopleInstructionSet = newConstantinopleInstructionSet()
	IstanbulInstructionSet       = newIstanbulInstructionSet()
	LondonInstructionSet         = newLondonInstructionSet()
	KoreInstructionSet           = newKoreInstructionSet()
	ShanghaiInstructionSet       = newShanghaiInstructionSet()
	CancunInstructionSet         = newCancunInstructionSet()
)
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{eip2565: false},
	common.BytesToAddress([]byte{6}):  &bn256AddByzantium{},
	common.BytesToAddress([]byte{7}):  &bn256ScalarMulByzantium{},
	common.BytesToAddress([]byte{8}):  &bn256PairingByzantium{},
	common.BytesToAddress([]byte{9}):  &vmLog{},
	common.BytesToAddress([]byte{10}): &feePayer{},
	common.BytesToAddress([]byte{11}): &validateSender{},
}

PrecompiledContractsByzantium contains the default set of pre-compiled Kaia contracts based on Ethereum Byzantium.

View Source 
var PrecompiledContractsCancun = 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{eip2565: true},
	common.BytesToAddress([]byte{6}):      &bn256AddIstanbul{},
	common.BytesToAddress([]byte{7}):      &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{8}):      &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{9}):      &blake2F{},
	common.BytesToAddress([]byte{0x0a}):   &kzgPointEvaluation{},
	common.BytesToAddress([]byte{3, 253}): &vmLog{},
	common.BytesToAddress([]byte{3, 254}): &feePayer{},
	common.BytesToAddress([]byte{3, 255}): &validateSender{},
}

PrecompiledContractsCancun contains the default set of pre-compiled Kaia contracts based on Ethereum Cancun.

View Source 
var PrecompiledContractsIstanbul = 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{eip2565: false},
	common.BytesToAddress([]byte{6}):      &bn256AddIstanbul{},
	common.BytesToAddress([]byte{7}):      &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{8}):      &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{9}):      &blake2F{},
	common.BytesToAddress([]byte{3, 253}): &vmLog{},
	common.BytesToAddress([]byte{3, 254}): &feePayer{},
	common.BytesToAddress([]byte{3, 255}): &validateSender{},
}

PrecompiledContractsIstanbul contains the default set of pre-compiled Kaia contracts based on Ethereum Istanbul.

View Source 
var PrecompiledContractsKore = 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{eip2565: true},
	common.BytesToAddress([]byte{6}):      &bn256AddIstanbul{},
	common.BytesToAddress([]byte{7}):      &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{8}):      &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{9}):      &blake2F{},
	common.BytesToAddress([]byte{3, 253}): &vmLog{},
	common.BytesToAddress([]byte{3, 254}): &feePayer{},
	common.BytesToAddress([]byte{3, 255}): &validateSender{},
}

PrecompiledContractsKore contains the default set of pre-compiled Kaia contracts based on Ethereum Berlin.

Functions

func ActivePrecompiles 

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

ActivePrecompiles returns the precompiles enabled with the current configuration.

func EnableEIP 

func EnableEIP(eipNum int, jt *JumpTable) error

EnableEIP enables the given EIP on the config. This operation writes in-place, and callers need to ensure that the globally defined jump tables are not polluted.

func PrintOpCodeExecTime 

func PrintOpCodeExecTime()

func RunPrecompiledContract 

func RunPrecompiledContract(p PrecompiledContract, input []byte, contract *Contract, evm *EVM) (ret []byte, computationCost uint64, 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 AccessListTracer 

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

AccessListTracer is a tracer that accumulates touched accounts and storage slots into an internal set.

func NewAccessListTracer 

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

NewAccessListTracer creates a new tracer that can generate AccessLists. An optional AccessList can be specified to occupy slots and addresses in the resulting accesslist.

func (*AccessListTracer) AccessList 

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

AccessList returns the current accesslist maintained by the tracer.

func (*AccessListTracer) CaptureEnd 

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

func (*AccessListTracer) CaptureEnter 

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

func (*AccessListTracer) CaptureExit 

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

func (*AccessListTracer) CaptureFault 

func (*AccessListTracer) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

func (*AccessListTracer) CaptureStart 

func (a *AccessListTracer) CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int)

func (*AccessListTracer) CaptureState 

func (a *AccessListTracer) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

CaptureState captures all opcodes that touch storage or addresses and adds them to the accesslist.

func (*AccessListTracer) CaptureTxEnd 

func (*AccessListTracer) CaptureTxEnd(restGas uint64)

func (*AccessListTracer) CaptureTxStart 

func (*AccessListTracer) CaptureTxStart(gasLimit uint64)

func (*AccessListTracer) Equal 

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

Equal returns if the content of two access list traces are equal.

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

func (AccountRef) FeePayer 

func (ar AccountRef) FeePayer() common.Address

type BlockContext 

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

	// Block information
	Coinbase    common.Address // Provides information for COINBASE
	Rewardbase  common.Address // Provides information for rewardbase when deferredTxfee is false
	GasLimit    uint64         // Provides information for GASLIMIT
	BlockNumber *big.Int       // Provides information for NUMBER
	Time        *big.Int       // Provides information for TIME
	BlockScore  *big.Int       // Provides information for DIFFICULTY
	BaseFee     *big.Int       // Provides information for BASEFEE
	Random      common.Hash    // Provides information for RANDOM
}

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

type CallFrame 

type CallFrame struct {
	Type         OpCode          `json:"-"` // e.g. CALL, DELEGATECALL, CREATE
	From         common.Address  `json:"from"`
	Gas          uint64          `json:"gas"`          // gasLeft. for top-level call, tx.gasLimit
	GasUsed      uint64          `json:"gasUsed"`      // gasUsed so far. for top-level call, tx.gasLimit - gasLeft = receipt.gasUsed
	To           *common.Address `json:"to,omitempty"` // recipient address, created contract address, or nil for failed contract creation,
	Input        []byte          `json:"input"`
	Output       []byte          `json:"output,omitempty"` // result of an internal call or revert message or runtime bytecode
	Error        string          `json:"error,omitempty"`
	RevertReason string          `json:"revertReason,omitempty"` // decoded revert message in geth style.
	Reverted     *RevertedInfo   `json:"reverted,omitempty"`     // decoded revert message and reverted contract address in klaytn style.
	Calls        []CallFrame     `json:"calls,omitempty"`        // child calls
	Value        *big.Int        `json:"value,omitempty"`
}

func (CallFrame) MarshalJSON 

func (c CallFrame) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (CallFrame) ToInternalTxTrace 

func (f CallFrame) ToInternalTxTrace() *InternalTxTrace

func (CallFrame) TypeString 

func (f CallFrame) TypeString() string

func (*CallFrame) UnmarshalJSON 

func (c *CallFrame) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type CallTracer 

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

Implements vm.Tracer interface

func NewCallTracer 

func NewCallTracer() *CallTracer

func (*CallTracer) CaptureEnd 

func (t *CallTracer) CaptureEnd(output []byte, gasUsed uint64, err error)

Exit top-level call frame

func (*CallTracer) CaptureEnter 

func (t *CallTracer) CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int)

Enter nested call frame

func (*CallTracer) CaptureExit 

func (t *CallTracer) CaptureExit(output []byte, gasUsed uint64, err error)

Exit nested call frame

func (*CallTracer) CaptureFault 

func (t *CallTracer) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

Fault during opcode execution

func (*CallTracer) CaptureStart 

func (t *CallTracer) CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int)

Enter top-level call frame

func (*CallTracer) CaptureState 

func (t *CallTracer) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

Each opcode

func (*CallTracer) CaptureTxEnd 

func (t *CallTracer) CaptureTxEnd(gasLeft uint64)

Transaction end

func (*CallTracer) CaptureTxStart 

func (t *CallTracer) CaptureTxStart(gasLimit uint64)

Transaction start

func (*CallTracer) GetResult 

func (t *CallTracer) GetResult() (CallFrame, error)

func (*CallTracer) Stop 

func (t *CallTracer) Stop(err error)

Stop terminates execution of the tracer at the first opportune moment. For CallTracer, it stops at CaptureEnter, which is the most repetitive operation.

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                   bool   // Enables debugging
	Tracer                  Tracer // Opcode logger
	NoRecursion             bool   // Disables call, callcode, delegate call and create
	EnablePreimageRecording bool   // Enables recording of SHA3/keccak preimages

	JumpTable JumpTable // EVM instruction table, automatically populated if unset

	// RunningEVM is to indicate the running EVM and used to stop the EVM.
	RunningEVM chan *EVM

	// ComputationCostLimit is the limit of the total computation cost of a transaction. Set infinite to disable the computation cost limit.
	ComputationCostLimit uint64

	// Enables collecting internal transaction data during processing a block
	EnableInternalTxTracing bool

	// Enables collecting and printing opcode execution time
	EnableOpDebug bool

	// Prefetching is true if the EVM is used for prefetching.
	Prefetching bool

	// Additional EIPs that are to be enabled
	ExtraEips []int
}

Config are the configuration options for the Interpreter

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
	FeePayerAddress common.Address

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

	Gas uint64
	// contains filtered or unexported fields
}

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

func NewContract 

func NewContract(caller types.ContractRef, object types.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) FeePayer 

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

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

type EVM 

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

	// virtual machine configuration options used to initialise the
	// evm.
	Config *Config
	// 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(blockCtx BlockContext, txCtx TxContext, 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 types.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 types.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(reason int32)

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() *params.ChainConfig

ChainConfig returns the environment's chain configuration

func (*EVM) Create 

func (evm *EVM) Create(caller types.ContractRef, code []byte, gas uint64, value *big.Int, codeFormat params.CodeFormat) (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 types.ContractRef, code []byte, gas uint64, endowment *big.Int, salt *uint256.Int, codeFormat params.CodeFormat) (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) CreateWithAddress 

func (evm *EVM) CreateWithAddress(caller types.ContractRef, code []byte, gas uint64, value *big.Int, contractAddr common.Address, humanReadable bool, codeFormat params.CodeFormat) ([]byte, common.Address, uint64, error)

CreateWithAddress creates a new contract using code as deployment code with given address and humanReadable.

func (*EVM) DelegateCall 

func (evm *EVM) DelegateCall(caller types.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) GetOpCodeComputationCost 

func (evm *EVM) GetOpCodeComputationCost() uint64

func (*EVM) GetPrecompiledContractMap 

func (evm *EVM) GetPrecompiledContractMap(addr common.Address) map[common.Address]PrecompiledContract

func (*EVM) Interpreter 

func (evm *EVM) Interpreter() *EVMInterpreter

Interpreter returns the EVM interpreter

func (*EVM) IsPrefetching 

func (evm *EVM) IsPrefetching() bool

func (*EVM) Reset 

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

Reset resets the EVM with a new transaction context.Reset This is not threadsafe and should only be done very cautiously.

func (*EVM) StaticCall 

func (evm *EVM) StaticCall(caller types.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 is used to run Kaia based contracts and will utilise the passed environment to query external sources for state information. The EVMInterpreter will run the byte code VM based on the passed configuration.

func NewEVMInterpreter 

func NewEVMInterpreter(evm *EVM) *EVMInterpreter

NewEVMInterpreter returns a new instance of the Interpreter.

func (*EVMInterpreter) Run 

func (in *EVMInterpreter) 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 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 InternalCall 

type InternalCall struct {
	Type  string          `json:"type"`
	From  *common.Address `json:"from"`
	To    *common.Address `json:"to"`
	Value string          `json:"value"`

	Gas     uint64 `json:"gas"`
	GasIn   uint64 `json:"gasIn"`
	GasUsed uint64 `json:"gasUsed"`
	GasCost uint64 `json:"gasCost"`

	Input  string `json:"input"`  // hex string
	Output string `json:"output"` // hex string
	Error  error  `json:"err"`

	OutOff *big.Int `json:"outoff"`
	OutLen *big.Int `json:"outlen"`

	Calls []*InternalCall `json:"calls"`
}

InternalCall is emitted to the EVM each cycle and lists information about the current internal state prior to the execution of the statement.

func (*InternalCall) ErrorString 

func (s *InternalCall) ErrorString() string

ErrorString formats the tracerLog's error as a string.

func (*InternalCall) OpName 

func (s *InternalCall) OpName() string

OpName formats the operand name in a human-readable format.

func (*InternalCall) ToTrace 

func (s *InternalCall) ToTrace() *InternalTxTrace

type InternalTxTrace 

type InternalTxTrace struct {
	Type  string          `json:"type"`
	From  *common.Address `json:"from,omitempty"`
	To    *common.Address `json:"to,omitempty"`
	Value string          `json:"value,omitempty"`

	Gas     uint64 `json:"gas,omitempty"`
	GasUsed uint64 `json:"gasUsed,omitempty"`

	Input  string `json:"input,omitempty"`  // hex string
	Output string `json:"output,omitempty"` // hex string
	Error  error  `json:"error,omitempty"`

	Time  time.Duration      `json:"time,omitempty"`
	Calls []*InternalTxTrace `json:"calls,omitempty"`

	RevertReason string        `json:"revertReason,omitempty"`
	Reverted     *RevertedInfo `json:"reverted,omitempty"`
}

InternalTxTrace is returned data after the end of trace-collecting cycle. It implements an object returned by "result" function at call_tracer.js

func (InternalTxTrace) MarshalJSON 

func (i InternalTxTrace) MarshalJSON() ([]byte, error)

func (*InternalTxTrace) UnmarshalJSON 

func (i *InternalTxTrace) UnmarshalJSON(input []byte) error

type InternalTxTracer 

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

InternalTxTracer is a full blown transaction tracer that extracts and reports all the internal calls made by a transaction, along with any useful information. It is ported to golang from JS, specifically call_tracer.js

func NewInternalTxTracer 

func NewInternalTxTracer() *InternalTxTracer

NewInternalTxTracer returns a new InternalTxTracer.

func (*InternalTxTracer) CaptureEnd 

func (t *InternalTxTracer) CaptureEnd(output []byte, gasUsed uint64, err error)

CaptureEnd is called after the call finishes to finalize the tracing.

func (*InternalTxTracer) CaptureEnter 

func (t *InternalTxTracer) CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int)

func (*InternalTxTracer) CaptureExit 

func (t *InternalTxTracer) CaptureExit(output []byte, gasUsed uint64, err error)

func (*InternalTxTracer) CaptureFault 

func (t *InternalTxTracer) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

CaptureFault implements the Tracer interface to trace an execution fault while running an opcode.

func (*InternalTxTracer) CaptureStart 

func (t *InternalTxTracer) CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int)

CaptureStart implements the Tracer interface to initialize the tracing operation.

func (*InternalTxTracer) CaptureState 

func (t *InternalTxTracer) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

CaptureState implements the Tracer interface to trace a single step of VM execution.

func (*InternalTxTracer) CaptureTxEnd 

func (t *InternalTxTracer) CaptureTxEnd(restGas uint64)

func (*InternalTxTracer) CaptureTxStart 

func (t *InternalTxTracer) CaptureTxStart(gasLimit uint64)

func (*InternalTxTracer) GetResult 

func (t *InternalTxTracer) GetResult() (*InternalTxTrace, error)

func (*InternalTxTracer) InternalTxLogs 

func (t *InternalTxTracer) InternalTxLogs() []*InternalCall

InternalTxLogs returns the captured tracerLog entries.

func (*InternalTxTracer) Stop 

func (t *InternalTxTracer) Stop(err error)

Stop terminates execution of the tracer at the first opportune moment.

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, err error)

CaptureEnd is triggered at end of execution.

func (*JSONLogger) CaptureEnter 

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

func (*JSONLogger) CaptureExit 

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

func (*JSONLogger) CaptureFault 

func (l *JSONLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

CaptureFault outputs state information on the logger.

func (*JSONLogger) CaptureStart 

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

func (*JSONLogger) CaptureState 

func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

CaptureState outputs state information on the logger. TODO: Add rData (return data) later

func (*JSONLogger) CaptureTxEnd 

func (l *JSONLogger) CaptureTxEnd(restGas uint64)

func (*JSONLogger) CaptureTxStart 

func (l *JSONLogger) CaptureTxStart(gasLimit uint64)

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
	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 Kaia virtual machine.

func NewMemory 

func NewMemory() *Memory

NewMemory returns a new memory model.

func (*Memory) Copy 

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

Copy copies data from the src position slice into the dst position. The source and destination may overlap. OBS: This operation assumes that any necessary memory expansion has already been performed, and this method may panic otherwise.

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

func (m *Memory) Increase(size uint64)

Increase increases the memory with size bytes

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.

func (*Memory) Slice 

func (m *Memory) Slice(begin, end int64) []byte

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 = 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  OpCode = 0x44
	PREVRANDAO  OpCode = 0x44
	GASLIMIT    OpCode = 0x45
	CHAINID     OpCode = 0x46
	SELFBALANCE OpCode = 0x47
	BASEFEE     OpCode = 0x48
	BLOBHASH    OpCode = 0x49
	BLOBBASEFEE OpCode = 0x4a
)

0x40 range - block operations. 

const (
	POP OpCode = 0x50 + iota
	MLOAD
	MSTORE
	MSTORE8
	SLOAD
	SSTORE
	JUMP
	JUMPI
	PC
	MSIZE
	GAS
	JUMPDEST
	TLOAD  OpCode = 0x5c
	TSTORE OpCode = 0x5d
	MCOPY  OpCode = 0x5e
	PUSH0  OpCode = 0x5f
)

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 = 0xfa

	REVERT       = 0xfd
	SELFDESTRUCT = 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 PrecompiledContract 

type PrecompiledContract interface {
	// GetRequiredGasAndComputationCost returns the gas and computation cost
	// required to execute the precompiled contract.
	GetRequiredGasAndComputationCost(input []byte) (uint64, uint64)

	// Run runs the precompiled contract
	// contract, evm is only exists in Kaia, those are not used in go-ethereum
	Run(input []byte, contract *Contract, evm *EVM) ([]byte, error)
}

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. If you want more information about Kaia's precompiled contracts, please refer https://docs.kaia.io/docs/learn/computation/precompiled-contracts/

type RevertedInfo 

type RevertedInfo struct {
	Contract *common.Address `json:"contract,omitempty"`
	Message  string          `json:"message,omitempty"`
}

func (RevertedInfo) MarshalJSON 

func (r RevertedInfo) MarshalJSON() ([]byte, error)

func (*RevertedInfo) UnmarshalJSON 

func (r *RevertedInfo) UnmarshalJSON(data []byte) error

type ScopeContext 

type ScopeContext struct {
	Memory   *Memory
	Stack    *Stack
	Contract *Contract
}

ScopeContext contains the things that are per-call, such as stack and memory, but not transients like pc and gas

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

type StateDB 

type StateDB interface {
	CreateAccount(common.Address)
	CreateSmartContractAccount(addr common.Address, format params.CodeFormat, r params.Rules)
	CreateSmartContractAccountWithKey(addr common.Address, humanReadable bool, key accountkey.AccountKey, format params.CodeFormat, r params.Rules)
	CreateEOA(addr common.Address, humanReadable bool, key accountkey.AccountKey)

	SubBalance(common.Address, *big.Int)
	AddBalance(common.Address, *big.Int)
	GetBalance(common.Address) *big.Int

	GetNonce(common.Address) uint64
	IncNonce(common.Address)
	SetNonce(common.Address, uint64)

	GetCodeHash(common.Address) common.Hash
	GetCode(common.Address) []byte
	SetCode(common.Address, []byte) error
	GetCodeSize(common.Address) int
	GetVmVersion(common.Address) (params.VmVersion, bool)

	AddRefund(uint64)
	SubRefund(uint64)
	GetRefund() uint64

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

	GetTransientState(addr common.Address, key common.Hash) common.Hash
	SetTransientState(addr common.Address, key, value common.Hash)

	SelfDestruct(common.Address)
	HasSelfDestructed(common.Address) bool

	SelfDestruct6780(common.Address)

	// UpdateKey updates the account's key with the given key.
	UpdateKey(addr common.Address, newKey accountkey.AccountKey, currentBlockNumber uint64) error

	// Exist reports whether the given account exists in state.
	// Notably this should also return true for self-destructed 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

	AddressInAccessList(addr common.Address) bool
	SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)
	// AddAddressToAccessList adds the given address to the access list. This operation is safe to perform
	// even if the feature/fork is not active yet
	AddAddressToAccessList(addr common.Address)
	// AddSlotToAccessList adds the given (address,slot) to the access list. This operation is safe to perform
	// even if the feature/fork is not active yet
	AddSlotToAccessList(addr common.Address, slot common.Hash)
	Prepare(rules params.Rules, sender, feePayer, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)

	RevertToSnapshot(int)
	Snapshot() int

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

	// IsProgramAccount returns true if the account implements ProgramAccount.
	IsProgramAccount(address common.Address) bool
	IsContractAvailable(address common.Address) bool
	IsValidCodeFormat(addr common.Address) bool

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

	GetTxHash() common.Hash

	GetKey(address common.Address) accountkey.AccountKey
}

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"`
	RefundCounter   uint64                      `json:"refund"`
	Computation     uint64                      `json:"computation"`
	ComputationCost uint64                      `json:"computationCost"`
	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, err error)

CaptureEnd is called after the call finishes to finalize the tracing.

func (*StructLogger) CaptureEnter 

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

func (*StructLogger) CaptureExit 

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

func (*StructLogger) CaptureFault 

func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)

CaptureFault implements the Tracer interface to trace an execution fault while running an opcode.

func (*StructLogger) CaptureStart 

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

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, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err 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) CaptureTxEnd 

func (l *StructLogger) CaptureTxEnd(restGas uint64)

func (*StructLogger) CaptureTxStart 

func (l *StructLogger) CaptureTxStart(gasLimit uint64)

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 {
	// Transaction level
	CaptureTxStart(gasLimit uint64)
	CaptureTxEnd(restGas uint64)
	// Top call frame
	CaptureStart(env *EVM, from common.Address, to common.Address, call bool, input []byte, gas uint64, value *big.Int)
	CaptureEnd(output []byte, gasUsed uint64, err error)
	// Rest of call frames
	CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int)
	CaptureExit(output []byte, gasUsed uint64, err error)
	// Opcode level
	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err error)
	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost, ccLeft, ccOpcode uint64, scope *ScopeContext, depth int, err 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 TxContext 

type TxContext struct {
	// Message information
	Origin   common.Address // Provides information for ORIGIN
	GasPrice *big.Int       // Provides information for GASPRICE
}

TxContext provides the EVM with information about a transaction. All fields can change between transactions.

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.