vm

package
v0.0.0-...-15e8d78 Latest Latest
Warning

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

 Go to latest Published: Apr 10, 2023 License: GPL-3.0, GPL-3.0 Imports: 31 Imported by: 0

Documentation

Overview

Package vm implements the Ethereum Virtual Machine.

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

Copyright 2014 The go-ethereum Authors This file is part of the go-ethereum library.

The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

Index

Constants

View Source 
const (
	GasQuickStep   uint64 = 2
	GasFastestStep uint64 = 3
	GasFastStep    uint64 = 5
	GasMidStep     uint64 = 8
	GasSlowStep    uint64 = 10
	GasExtStep     uint64 = 20
)

Gas costs

View Source 
const StakeABIJSON = `` /* 6700-byte string literal not displayed */

Variables

View Source 
var (
	// ErrInvalidSubroutineEntry means that a BEGINSUB was reached via iteration,
	// as opposed to from a JUMPSUB instruction
	ErrInvalidSubroutineEntry     = errors.New("invalid subroutine entry")
	ErrOutOfGas                   = errors.New("out of gas")
	ErrCodeStoreOutOfGas          = errors.New("contract creation code storage out of gas")
	ErrDepth                      = errors.New("max call depth exceeded")
	ErrInsufficientBalance        = errors.New("insufficient balance for transfer")
	ErrInsufficientBalanceForAll  = errors.New("insufficient balance for transfer and fee ")
	ErrContractAddressCollision   = errors.New("contract address collision")
	ErrExecutionReverted          = errors.New("execution reverted")
	ErrMaxCodeSizeExceeded        = errors.New("max code size exceeded")
	ErrInvalidJump                = errors.New("invalid jump destination")
	ErrWriteProtection            = errors.New("write protection")
	ErrReturnDataOutOfBounds      = errors.New("return data out of bounds")
	ErrGasUintOverflow            = errors.New("gas uint64 overflow")
	ErrInvalidRetsub              = errors.New("invalid retsub")
	ErrReturnStackExceeded        = errors.New("return stack limit reached")
	ErrStakingInvalidInput        = errors.New("invalid input for staking")
	ErrStakingInsufficientBalance = errors.New("insufficient balance for staking transfer")
)

List evm execution errors

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.

View Source 
var PrecompiledContractsPoS = 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{},
	types.StakingAddress:             &staking{},
}

PrecompiledContractsPoS contains the default set of pre-compiled Ethereum contracts used in the dpos release.

View Source 
var PrecompiledContractsYoloPos = 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}):  &bn256AddIstanbul{},
	common.BytesToAddress([]byte{7}):  &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{8}):  &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{9}):  &blake2F{},
	common.BytesToAddress([]byte{10}): &bls12381G1Add{},
	common.BytesToAddress([]byte{11}): &bls12381G1Mul{},
	common.BytesToAddress([]byte{12}): &bls12381G1MultiExp{},
	common.BytesToAddress([]byte{13}): &bls12381G2Add{},
	common.BytesToAddress([]byte{14}): &bls12381G2Mul{},
	common.BytesToAddress([]byte{15}): &bls12381G2MultiExp{},
	common.BytesToAddress([]byte{16}): &bls12381Pairing{},
	common.BytesToAddress([]byte{17}): &bls12381MapG1{},
	common.BytesToAddress([]byte{18}): &bls12381MapG2{},
	types.StakingAddress:              &staking{},
}

PrecompiledContractsYoloPos contains the default set of pre-compiled Ethereum contracts used in the Yolo v1 test release.

View Source 
var StakingGas = map[string]uint64{
	"getDeposit":       360000,
	"getDelegate":      450000,
	"lockedBalance":    30000,
	"deposit":          2400000,
	"append":           2400000,
	"setFee":           2400000,
	"setPubkey":        2400000,
	"withdraw":         2520000,
	"cancel":           2400000,
	"delegate":         1500000,
	"undelegate":       1500000,
	"withdrawDelegate": 1620000,
}

StakingGas defines all method gas

Functions

func ActivateableEips 

func ActivateableEips() []string

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 GenesisAddLockedBalance 

func GenesisAddLockedBalance(db StateDB, addr common.Address, amount *big.Int)

func GetCurrentValidators 

func GetCurrentValidators(state StateDB) []*types.CommitteeMember

func GetValidatorsByEpoch 

func GetValidatorsByEpoch(state StateDB, eid, hh uint64) []*types.CommitteeMember

func NewMarkdownLogger 

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

NewMarkdownLogger creates a logger which outputs information in a format adapted for human readability, and is also a valid markdown table

func RunPrecompiledContract 

func RunPrecompiledContract(evm *EVM, p PrecompiledContract, input []byte, suppliedGas uint64, contract *Contract) (ret []byte, remainingGas uint64, err error)

RunPrecompiledContract runs and evaluates the output of a precompiled contract. It returns - the returned bytes, - the _remaining_ gas, - any error that occurred

func RunStaking 

func RunStaking(evm *EVM, contract *Contract, input []byte) (ret []byte, err error)

RunStaking execute abeychain staking contract

func ValidEip 

func ValidEip(eipNum int) bool

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 AlterableInfo 

type AlterableInfo struct {
	Fee        *big.Int
	VotePubkey []byte
}

type CallContext 

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

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

type CanTransferFunc 

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

CanTransferFunc is the signature of a transfer guard function

type CancelableAsset 

type CancelableAsset struct {
	Value   string
	Address common.Address
}

func (CancelableAsset) MarshalJSON 

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

MarshalJSON marshals as JSON.

func (*CancelableAsset) UnmarshalJSON 

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

UnmarshalJSON unmarshals from JSON.

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 [256]*operation // EVM instruction table, automatically populated if unset

	EWASMInterpreter string // External EWASM interpreter options
	EVMInterpreter   string // External EVM interpreter options

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

Config are the configuration options for the Interpreter

type Context 

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

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

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

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

type Contract 

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

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

	Gas uint64
	// contains filtered or unexported fields
}

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

func NewContract 

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

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

func (*Contract) Address 

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

Address returns the contracts address

func (*Contract) AsDelegate 

func (c *Contract) AsDelegate() *Contract

AsDelegate sets the contract to be a delegate call and returns the current contract (for chaining calls)

func (*Contract) Caller 

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

Caller returns the caller of the contract.

Caller will recursively call caller when the contract is a delegate call, including that of caller's caller.

func (*Contract) GetByte 

func (c *Contract) GetByte(n uint64) byte

GetByte returns the n'th byte in the contract's byte array

func (*Contract) GetOp 

func (c *Contract) GetOp(n uint64) OpCode

GetOp returns the n'th element in the contract's byte array

func (*Contract) SetCallCode 

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

SetCallCode sets the code of the contract and address of the backing data object

func (*Contract) SetCodeOptionalHash 

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

SetCodeOptionalHash can be used to provide code, but it's optional to provide hash. In case hash is not provided, the jumpdest analysis will not be saved to the parent context

func (*Contract) UseGas 

func (c *Contract) UseGas(gas uint64) (ok bool)

UseGas attempts the use gas and subtracts it and returns true on success

func (*Contract) Value 

func (c *Contract) Value() *big.Int

Value returns the contract's value (sent to it from it's caller)

type ContractRef 

type ContractRef interface {
	Address() common.Address
}

ContractRef is a reference to the contract's backing object

type DelegationAccount 

type DelegationAccount struct {
	SaAddress common.Address
	Unit      *impawnUnit
}

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

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

func (*EVM) CallCode 

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

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

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

func (*EVM) Cancel 

func (evm *EVM) Cancel()

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

func (*EVM) Cancelled 

func (evm *EVM) Cancelled() bool

Cancelled returns true if Cancel has been called

func (*EVM) ChainConfig 

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

Create creates a new contract using code as deployment code.

func (*EVM) Create2 

func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *uint256.Int, fee *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.

func (*EVM) DelegateCall 

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

DelegateCall executes the contract associated with the addr with the given input as parameters. It reverses the state in case of an execution error.

DelegateCall differs from CallCode in the sense that it executes the given address' code with the caller as context and the caller is set to the caller of the caller.

func (*EVM) 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.

type EVMInterpreter 

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

EVMInterpreter represents an EVM interpreter

func NewEVMInterpreter 

func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter

NewEVMInterpreter returns a new instance of the Interpreter.

func (*EVMInterpreter) CanRun 

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

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

func (*EVMInterpreter) Run 

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

Run loops and evaluates the contract's code with the given input data and returns the return byte-slice and an error if one occurred.

It's important to note that any errors returned by the interpreter should be considered a revert-and-consume-all-gas operation except for ErrExecutionReverted which means revert-and-keep-gas-left.

type ErrInvalidOpCode 

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

ErrInvalidOpCode wraps an evm error when an invalid opcode is encountered.

func (*ErrInvalidOpCode) Error 

func (e *ErrInvalidOpCode) Error() string

type ErrStackOverflow 

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

ErrStackOverflow wraps an evm error when the items on the stack exceeds the maximum allowance.

func (*ErrStackOverflow) Error 

func (e *ErrStackOverflow) Error() string

type ErrStackUnderflow 

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

ErrStackUnderflow wraps an evm error when the items on the stack less than the minimal requirement.

func (*ErrStackUnderflow) Error 

func (e *ErrStackUnderflow) Error() string

type GetHashFunc 

type GetHashFunc func(uint64) common.Hash

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

type ImpawnCache 

type ImpawnCache struct {
	Cache *lru.Cache
	// contains filtered or unexported fields
}
var IC *ImpawnCache

///////////////////////////////////////////////////////////////////////////////

type ImpawnImpl 

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

/////////////////////////////////////////////////////////////////////////////// be thread-safe for caller locked

func CloneImpawnImpl 

func CloneImpawnImpl(ori *ImpawnImpl) *ImpawnImpl

func NewImpawnImpl 

func NewImpawnImpl() *ImpawnImpl

func (*ImpawnImpl) AppendSAAmount 

func (i *ImpawnImpl) AppendSAAmount(height uint64, addr common.Address, val *big.Int) error

func (*ImpawnImpl) CancelDAccount 

func (i *ImpawnImpl) CancelDAccount(curHeight uint64, addrSA, addrDA common.Address, amount *big.Int) error

CancelDAccount cancel amount of asset for delegation account,it will be work in next epoch

func (*ImpawnImpl) CancelSAccount 

func (i *ImpawnImpl) CancelSAccount(curHeight uint64, addr common.Address, amount *big.Int) error

CancelSAccount cancel amount of asset for staking account,it will be work in next epoch

func (*ImpawnImpl) Counts 

func (i *ImpawnImpl) Counts() int

func (*ImpawnImpl) DecodeRLP 

func (i *ImpawnImpl) DecodeRLP(s *rlp.Stream) error

func (*ImpawnImpl) DoElections 

func (i *ImpawnImpl) DoElections(epochid, height uint64) ([]*StakingAccount, error)

DoElections called by consensus while it closer the end of epoch,have 500~1000 fast block

func (*ImpawnImpl) EncodeRLP 

func (i *ImpawnImpl) EncodeRLP(w io.Writer) error

EncodeRLP serializes b into the abeychain RLP ImpawnImpl format.

func (*ImpawnImpl) GetAllCancelableAsset 

func (i *ImpawnImpl) GetAllCancelableAsset(addr common.Address) map[common.Address]*big.Int

GetAllCancelableAsset returns all asset on addr it can be canceled

func (*ImpawnImpl) GetAllCancelableAssetRPC 

func (i *ImpawnImpl) GetAllCancelableAssetRPC(addr common.Address) []CancelableAsset

func (*ImpawnImpl) GetAllStakingAccount 

func (i *ImpawnImpl) GetAllStakingAccount() SAImpawns

/////////////////////////////////////////////////////////////////////////////// GetStakings return all staking accounts of the current epoch

func (*ImpawnImpl) GetAllStakingAccountRPC 

func (i *ImpawnImpl) GetAllStakingAccountRPC(height uint64) map[string]interface{}

func (*ImpawnImpl) GetLockedAsset 

func (i *ImpawnImpl) GetLockedAsset(addr common.Address) map[common.Address]*types.StakingValue

GetLockedAsset returns a group canceled asset from the state of the addr,it includes redemption on maturity and unmaturity asset

func (*ImpawnImpl) GetLockedAsset2 

func (i *ImpawnImpl) GetLockedAsset2(addr common.Address, height uint64) map[common.Address]*types.LockedValue

func (*ImpawnImpl) GetLockedAssetRPC 

func (i *ImpawnImpl) GetLockedAssetRPC(addr common.Address, height uint64) []LockedAsset

func (*ImpawnImpl) GetRoot 

func (i *ImpawnImpl) GetRoot() common.Hash

/////////////////////////////////////////////////////////////////////////////// storage layer

func (*ImpawnImpl) GetStakingAccount 

func (i *ImpawnImpl) GetStakingAccount(epochid uint64, addr common.Address) (*StakingAccount, error)

func (*ImpawnImpl) GetStakingAccountRPC 

func (i *ImpawnImpl) GetStakingAccountRPC(height uint64, address common.Address) map[string]interface{}

func (*ImpawnImpl) GetStakingAsset 

func (i *ImpawnImpl) GetStakingAsset(addr common.Address) map[common.Address]*types.StakingValue

GetStakingAsset returns a map for all staking amount of the address, the key is the SA address

func (*ImpawnImpl) GetStakingAssetRPC 

func (i *ImpawnImpl) GetStakingAssetRPC(addr common.Address) []StakingAsset

func (*ImpawnImpl) InsertDAccount2 

func (i *ImpawnImpl) InsertDAccount2(height uint64, addrSA, addrDA common.Address, val *big.Int) error

func (*ImpawnImpl) InsertSAccount2 

func (i *ImpawnImpl) InsertSAccount2(height, effectHeight uint64, addr common.Address, pk []byte, val *big.Int, fee *big.Int, auto bool) error

func (*ImpawnImpl) Load 

func (i *ImpawnImpl) Load(state StateDB, preAddress common.Address) error

func (*ImpawnImpl) MakeModifyStateByTip10 

func (i *ImpawnImpl) MakeModifyStateByTip10()

func (*ImpawnImpl) RedeemDAccount 

func (i *ImpawnImpl) RedeemDAccount(curHeight uint64, addrSA, addrDA common.Address, amount *big.Int) error

RedeemDAccount redeem amount of asset for delegation account,it will locked for a certain time

func (*ImpawnImpl) RedeemSAccount 

func (i *ImpawnImpl) RedeemSAccount(curHeight uint64, addr common.Address, amount *big.Int) error

RedeemSAccount redeem amount of asset for staking account,it will locked for a certain time

func (*ImpawnImpl) Reward 

func (i *ImpawnImpl) Reward(block *types.SnailBlock, allAmount *big.Int, effectid uint64) ([]*types.SARewardInfos, error)

func (*ImpawnImpl) Reward2 

func (i *ImpawnImpl) Reward2(begin, end, effectid uint64, allAmount *big.Int) ([]*types.SARewardInfos, error)

func (*ImpawnImpl) Save 

func (i *ImpawnImpl) Save(state StateDB, preAddress common.Address) error

func (*ImpawnImpl) SetCurrentEpoch 

func (i *ImpawnImpl) SetCurrentEpoch(eid uint64)

func (*ImpawnImpl) Shift 

func (i *ImpawnImpl) Shift(epochid, effectHeight uint64) error

Shift will move the staking account which has election flag to the next epoch it will be save the whole state in the current epoch end block after it called by consensus

func (*ImpawnImpl) Summay 

func (i *ImpawnImpl) Summay() *types.ImpawnSummay

func (*ImpawnImpl) UpdateSAFee 

func (i *ImpawnImpl) UpdateSAFee(height uint64, addr common.Address, fee *big.Int) error

func (*ImpawnImpl) UpdateSAPK 

func (i *ImpawnImpl) UpdateSAPK(height uint64, addr common.Address, pk []byte) error

type Interpreter 

type Interpreter interface {
	// Run loops and evaluates the contract's code with the given input data and returns
	// the return byte-slice and an error if one occurred.
	Run(contract *Contract, input []byte, static bool) ([]byte, error)
	// CanRun tells if the contract, passed as an argument, can be
	// run by the current interpreter. This is meant so that the
	// caller can do something like:
	//
	// “`golang
	// for _, interpreter := range interpreters {
	//   if interpreter.CanRun(contract.code) {
	//     interpreter.Run(contract.code, input)
	//   }
	// }
	// “`
	CanRun([]byte) bool
}

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

type JSONLogger 

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

func NewJSONLogger 

func NewJSONLogger(cfg *LogConfig, writer io.Writer) *JSONLogger

NewJSONLogger creates a new EVM tracer that prints execution steps as JSON objects into the provided stream.

func (*JSONLogger) CaptureEnd 

func (l *JSONLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error

CaptureEnd is triggered at end of execution.

func (*JSONLogger) CaptureFault 

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

CaptureFault outputs state information on the logger.

func (*JSONLogger) CaptureStart 

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

func (*JSONLogger) CaptureState 

func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error

CaptureState outputs state information on the logger.

type JumpTable 

type JumpTable [256]*operation

JumpTable contains the EVM opcodes supported at a given fork.

type LockValue 

type LockValue struct {
	EpochID uint64
	Amount  string
	Height  *big.Int
	Locked  bool
}

func (LockValue) MarshalJSON 

func (l LockValue) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*LockValue) UnmarshalJSON 

func (l *LockValue) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type LockedAsset 

type LockedAsset struct {
	LockValue []*LockValue   `json:"lockValue"`
	Address   common.Address `json:"address"`
}

func (LockedAsset) MarshalJSON 

func (l LockedAsset) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*LockedAsset) UnmarshalJSON 

func (l *LockedAsset) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type LogConfig 

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

LogConfig are the configuration options for structured logger the EVM

type Memory 

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

Memory implements a simple memory model for the ethereum virtual machine.

func NewMemory 

func NewMemory() *Memory

NewMemory returns a new memory model.

func (*Memory) Data 

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

Data returns the backing slice

func (*Memory) GetCopy 

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

Get returns offset + size as a new slice

func (*Memory) GetPtr 

func (m *Memory) GetPtr(offset, size int64) []byte

GetPtr returns the offset + size

func (*Memory) Len 

func (m *Memory) Len() int

Len returns the length of the backing slice

func (*Memory) Print 

func (m *Memory) Print()

Print dumps the content of the memory.

func (*Memory) Resize 

func (m *Memory) Resize(size uint64)

Resize resizes the memory to size

func (*Memory) Set 

func (m *Memory) Set(offset, size uint64, value []byte)

Set sets offset + size to value

func (*Memory) Set32 

func (m *Memory) Set32(offset uint64, val *uint256.Int)

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

type OpCode 

type OpCode byte

OpCode is an EVM opcode 

const (
	STOP OpCode = iota
	ADD
	MUL
	SUB
	DIV
	SDIV
	MOD
	SMOD
	ADDMOD
	MULMOD
	EXP
	SIGNEXTEND
)

0x0 range - arithmetic ops. 

const (
	LT OpCode = iota + 0x10
	GT
	SLT
	SGT
	EQ
	ISZERO
	AND
	OR
	XOR
	NOT
	BYTE
	SHL
	SHR
	SAR

	SHA3 OpCode = 0x20
)

0x10 range - comparison ops. 

const (
	ADDRESS OpCode = 0x30 + iota
	BALANCE
	ORIGIN
	CALLER
	CALLVALUE
	CALLDATALOAD
	CALLDATASIZE
	CALLDATACOPY
	CODESIZE
	CODECOPY
	GASPRICE
	EXTCODESIZE
	EXTCODECOPY
	RETURNDATASIZE
	RETURNDATACOPY
	EXTCODEHASH
)

0x30 range - closure state. 

const (
	BLOCKHASH OpCode = 0x40 + iota
	COINBASE
	TIMESTAMP
	NUMBER
	DIFFICULTY
	GASLIMIT
	CHAINID     OpCode = 0x46
	SELFBALANCE OpCode = 0x47
)

0x40 range - block operations. 

const (
	POP       OpCode = 0x50
	MLOAD     OpCode = 0x51
	MSTORE    OpCode = 0x52
	MSTORE8   OpCode = 0x53
	SLOAD     OpCode = 0x54
	SSTORE    OpCode = 0x55
	JUMP      OpCode = 0x56
	JUMPI     OpCode = 0x57
	PC        OpCode = 0x58
	MSIZE     OpCode = 0x59
	GAS       OpCode = 0x5a
	JUMPDEST  OpCode = 0x5b
	BEGINSUB  OpCode = 0x5c
	RETURNSUB OpCode = 0x5d
	JUMPSUB   OpCode = 0x5e
)

0x50 range - 'storage' and execution. 

const (
	PUSH1 OpCode = 0x60 + iota
	PUSH2
	PUSH3
	PUSH4
	PUSH5
	PUSH6
	PUSH7
	PUSH8
	PUSH9
	PUSH10
	PUSH11
	PUSH12
	PUSH13
	PUSH14
	PUSH15
	PUSH16
	PUSH17
	PUSH18
	PUSH19
	PUSH20
	PUSH21
	PUSH22
	PUSH23
	PUSH24
	PUSH25
	PUSH26
	PUSH27
	PUSH28
	PUSH29
	PUSH30
	PUSH31
	PUSH32
	DUP1
	DUP2
	DUP3
	DUP4
	DUP5
	DUP6
	DUP7
	DUP8
	DUP9
	DUP10
	DUP11
	DUP12
	DUP13
	DUP14
	DUP15
	DUP16
	SWAP1
	SWAP2
	SWAP3
	SWAP4
	SWAP5
	SWAP6
	SWAP7
	SWAP8
	SWAP9
	SWAP10
	SWAP11
	SWAP12
	SWAP13
	SWAP14
	SWAP15
	SWAP16
)

0x60 range. 

const (
	LOG0 OpCode = 0xa0 + iota
	LOG1
	LOG2
	LOG3
	LOG4
)

0xa0 range - logging ops. 

const (
	PUSH OpCode = 0xb0 + iota
	DUP
	SWAP
)

unofficial opcodes used for parsing. 

const (
	CREATE OpCode = 0xf0 + iota
	CALL
	CALLCODE
	RETURN
	DELEGATECALL
	CREATE2
	STATICCALL   OpCode = 0xfa
	REVERT       OpCode = 0xfd
	SELFDESTRUCT OpCode = 0xff
)

0xf0 range - closures.

func StringToOp 

func StringToOp(str string) OpCode

StringToOp finds the opcode whose name is stored in `str`.

func (OpCode) IsPush 

func (op OpCode) IsPush() bool

IsPush specifies if an opcode is a PUSH opcode.

func (OpCode) IsStaticJump 

func (op OpCode) IsStaticJump() bool

IsStaticJump specifies if an opcode is JUMP.

func (OpCode) String 

func (op OpCode) String() string

type PairstakingValue 

type PairstakingValue struct {
	Amount *big.Int
	Height *big.Int
	State  uint8
}

///////////////////////////////////////////////////////////////////////////////

type PrecompiledContract 

type PrecompiledContract interface {
	RequiredGas(evm *EVM, input []byte) uint64                      // RequiredPrice calculates the contract gas use
	Run(evm *EVM, contract *Contract, 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 RedeemItem 

type RedeemItem struct {
	Amount  *big.Int
	EpochID uint64
	State   uint8
}

type ReturnStack 

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

ReturnStack is an object for basic return stack operations.

type RewardItem 

type RewardItem struct {
	Amount *big.Int
	Height *big.Int
}

type SAImpawns 

type SAImpawns []*StakingAccount

type Stack 

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

Stack is an object for basic stack operations. Items popped to the stack are expected to be changed and modified. stack does not take care of adding newly initialised objects.

func (*Stack) Back 

func (st *Stack) Back(n int) *uint256.Int

Back returns the n'th item in stack

func (*Stack) Data 

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

Data returns the underlying uint256.Int array.

func (*Stack) Print 

func (st *Stack) Print()

Print dumps the content of the stack

type StakeContract 

type StakeContract struct{}

type StakingAccount 

type StakingAccount struct {
	Unit       *impawnUnit
	Votepubkey []byte
	Fee        *big.Int
	Committee  bool
	Delegation []*DelegationAccount
	Modify     *AlterableInfo
}

type StakingAsset 

type StakingAsset struct {
	StakingValue []*StakingValue `json:"stakingValue"`
	Address      common.Address  `json:"address"`
}

func (StakingAsset) MarshalJSON 

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

MarshalJSON marshals as JSON.

func (*StakingAsset) UnmarshalJSON 

func (s *StakingAsset) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type StakingValue 

type StakingValue struct {
	Height uint64
	Amount string
}

func (StakingValue) MarshalJSON 

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

MarshalJSON marshals as JSON.

func (*StakingValue) UnmarshalJSON 

func (s *StakingValue) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type StateDB 

type StateDB interface {
	CreateAccount(common.Address)

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

	GetUnlockedBalance(addr common.Address) *big.Int
	GetPOSLocked(addr common.Address) *big.Int
	SetPOSLocked(addr common.Address, value *big.Int)

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

	GetCodeHash(common.Address) common.Hash
	GetCode(common.Address) []byte
	SetCode(common.Address, []byte)
	GetCodeSize(common.Address) int

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

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

	GetPOSState(common.Address, common.Hash) []byte
	SetPOSState(common.Address, common.Hash, []byte)

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

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

	RevertToSnapshot(int)
	Snapshot() int

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

	ForEachStorage(common.Address, func(common.Hash, common.Hash) bool)
	ForEachPOSStorage(common.Address, func(common.Hash, []byte) 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"`
	ReturnStack   []uint32                    `json:"returnStack"`
	ReturnData    []byte                      `json:"returnData"`
	Storage       map[common.Hash]common.Hash `json:"-"`
	Depth         int                         `json:"depth"`
	RefundCounter uint64                      `json:"refund"`
	Err           error                       `json:"-"`
}

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

func (*StructLog) ErrorString 

func (s *StructLog) ErrorString() string

ErrorString formats the log's error as a string.

func (StructLog) MarshalJSON 

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

MarshalJSON marshals as JSON.

func (*StructLog) OpName 

func (s *StructLog) OpName() string

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

func (*StructLog) UnmarshalJSON 

func (s *StructLog) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type StructLogger 

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

StructLogger is an EVM state logger and implements Tracer.

StructLogger can capture state based on the given Log configuration and also keeps a track record of modified storage which is used in reporting snapshots of the contract their storage.

func NewStructLogger 

func NewStructLogger(cfg *LogConfig) *StructLogger

NewStructLogger returns a new logger

func (*StructLogger) CaptureEnd 

func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error

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

func (*StructLogger) CaptureFault 

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

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

func (*StructLogger) CaptureStart 

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

CaptureStart implements the Tracer interface to initialize the tracing operation.

func (*StructLogger) CaptureState 

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

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

CaptureState also tracks SLOAD/SSTORE ops to track storage change.

func (*StructLogger) Error 

func (l *StructLogger) Error() error

Error returns the VM error captured by the trace.

func (*StructLogger) Output 

func (l *StructLogger) Output() []byte

Output returns the VM return value captured by the trace.

func (*StructLogger) StructLogs 

func (l *StructLogger) StructLogs() []StructLog

StructLogs returns the captured log entries.

type Tracer 

type Tracer interface {
	CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error
	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error
	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error
	CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error
}

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

type TransferFunc 

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

TransferFunc is the signature of a transfer function

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.