vm

package

Go to main page

Versions in this module

v1

v1.2.2

Mar 1, 2024

v1.2.1

Feb 19, 2024

v1.1.5

Jul 7, 2023

v1.1.4

Apr 26, 2023

v1.1.3

Apr 6, 2023

v1.1.0

Jan 18, 2023

v1.0.3

Dec 18, 2022

v1.0.1

Nov 9, 2022

v1.0.0

Nov 4, 2022

Changes in this version

+ const EventOfUpdate

v0

v0.6.6

Sep 8, 2022

v0.6.5

Sep 1, 2022

v0.6.3

Aug 31, 2022

v0.6.2

Aug 29, 2022

v0.5.5

Aug 3, 2022

v0.5.4

Aug 1, 2022

Changes in this version

+ const VerifyProof

v0.5.3

Jun 27, 2022

v0.5.2

Jun 17, 2022

v0.5.1

Jun 1, 2022

v0.5.0

May 9, 2022

v0.4.3

Apr 15, 2022

v0.4.2

Apr 1, 2022

Changes in this version

+ func GetRelayerAddress(state *state.StateDB) common.Address

v0.4.1

Mar 18, 2022

Changes in this version

+ const GetRelayer

+ const Reset

+ const SetRelayer

v0.3.4

Dec 30, 2021

Changes in this version

+ var ErrBlockNumberOutOfBounds = errors.New("block number out of bounds")

+ var ErrEngineIncompatible = errors.New("blockchain engine incompatible with request")

+ var ErrInputDecode = errors.New("unable to decode input")

+ var ErrInputLength = errors.New("invalid input length")

+ var ErrInputVerification = errors.New("unable to verify header")

+ var ErrInvalidRetsub = errors.New("invalid retsub")

+ var ErrInvalidSubroutineEntry = errors.New("invalid subroutine entry")

+ var ErrNoCompatibleInterpreter = errors.New("no compatible interpreter")

+ var ErrReturnStackExceeded = errors.New("return stack limit reached")

+ var ErrUnexpected = errors.New("unexpected execution error")

+ var ErrValidatorsOutOfBounds = errors.New("validator index out of bounds")

type BlockContext

+ EpochSize uint64

+ GasPrice *big.Int

+ GetHeaderByNumber GetHeaderByNumberFunc

+ GetRegisteredAddress GetRegisteredAddressFunc

+ GetValidators GetValidatorsFunc

+ Origin common.Address

+ VerifySeal VerifySealFunc

type EVM

+ func (evm *EVM) GetDebug() bool

+ func (evm *EVM) GetStateDB() StateDB

+ func (evm *EVM) SetDebug(value bool)

+ type GetHeaderByNumberFunc func(uint64) *types.Header

+ type GetRegisteredAddressFunc func(evm *EVM, registryId common.Hash) (common.Address, error)

+ type GetValidatorsFunc func(blockNumber *big.Int, headerHash common.Hash) []istanbul.Validator

+ type VerifySealFunc func(*types.Header) bool

v0.3.3

Dec 10, 2021

v0.3.2

Nov 29, 2021

v0.3.1

Nov 23, 2021

Changes in this version

+ const TxVerify

+ var ErrInvalidCode = errors.New("invalid code: must not begin with 0xef")

+ var TxVerifyGas = map[string]uint64

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

type AccessListTracer

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

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

type BlockContext

+ BaseFee *big.Int

type Config

+ NoBaseFee bool

type EVM

+ Config Config

+ func (evm *EVM) StartGasMetering()

+ func (evm *EVM) StopGasMetering()

+ type EVMRunner interface

+ Execute func(recipient common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, err error)

+ ExecuteFrom func(sender, recipient common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, err error)

+ Query func(recipient common.Address, input []byte, gas uint64) (ret []byte, err error)

+ StartGasMetering func()

+ StopGasMetering func()

type JSONLogger

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

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

type LogConfig

+ EnableMemory bool

+ EnableReturnData bool

type OpCode

+ const BASEFEE

type RegisterImpl

+ func (i *RegisterImpl) GetCurrentEpochID() uint64

type StructLogger

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

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

+ func (l *StructLogger) Reset()

type Tracer

+ CaptureEnter func(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, ...)

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

v0.1.1

Aug 13, 2021

Changes in this version

+ const CacheSize

+ const ColdAccountAccessCostEIP2929

+ const ColdSloadCostEIP2929

+ const CurNbrAndHash

+ const GasExtStep

+ const GasFastStep

+ const GasFastestStep

+ const GasMidStep

+ const GasQuickStep

+ const GasSlowStep

+ const Save

+ const TimesLimit

+ const WarmStorageReadCostEIP2929

+ var ErrCodeStoreOutOfGas = errors.New("contract creation code storage out of gas")

+ var ErrContractAddressCollision = errors.New("contract address collision")

+ var ErrDepth = errors.New("max call depth exceeded")

+ var ErrExecutionReverted = errors.New("execution reverted")

+ var ErrGasUintOverflow = errors.New("gas uint64 overflow")

+ var ErrInsufficientBalance = errors.New("insufficient balance for transfer")

+ var ErrInvalidJump = errors.New("invalid jump destination")

+ var ErrMaxCodeSizeExceeded = errors.New("max code size exceeded")

+ var ErrNotSupportChain = errors.New("not support chain")

+ var ErrOutOfGas = errors.New("out of gas")

+ var ErrRLPDecode = errors.New("rlp decode error")

+ var ErrReturnDataOutOfBounds = errors.New("return data out of bounds")

+ var ErrWriteProtection = errors.New("write protection")

+ var PrecompiledAddressesBerlin []common.Address

+ var PrecompiledAddressesByzantium []common.Address

+ var PrecompiledAddressesHomestead []common.Address

+ var PrecompiledAddressesIstanbul []common.Address

+ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract

+ var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract

+ var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract

+ var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract

+ var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract

+ var SyncGas = map[string]uint64

+ func ActivateableEips() []string

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

+ func CopyVotePk(pk []byte) []byte

+ func DeepCopy(src, dst interface{}) error

+ func EnableEIP(eipNum int, jt *JumpTable) error

+ func ForbidAddress(addr common.Address) error

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

+ func GetCurrentEpochID(evm *EVM) (uint64, error)

+ func GetCurrentRelayer(state StateDB) []*params.RelayerMember

+ func GetRelayersByEpoch(state StateDB, eid, hh uint64) []*params.RelayerMember

+ func HistoryWorkEfficiency(state StateDB, epochId uint64, relayer common.Address) (uint64, error)

+ func IsInCurrentEpoch(state StateDB, relayer common.Address) bool

+ func IsUnlocked(eid, height uint64) bool

+ func MergeReward(map1, map2 map[common.Address]*big.Int) map[common.Address]*big.Int

+ func MinCalcRedeemHeight(eid uint64) uint64

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

+ func RlpHash(x interface{}) (h common.Hash)

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

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

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

+ func ToJSON(ii *RegisterSummay) map[string]interface

+ func ValidEip(eipNum int) bool

+ func ValidPk(pk []byte) error

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

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

+ type AccessListTracer struct

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

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

+ func (*AccessListTracer) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

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

+ func (a *AccessListTracer) CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, ...)

+ func (a *AccessListTracer) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

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

+ type AccountRef common.Address

+ func (ar AccountRef) Address() common.Address

+ type AlterableInfo struct

+ Fee *big.Int

+ VotePubkey []byte

+ type BalanceInfo struct

+ Address common.Address

+ Lock *big.Int

+ Valid *big.Int

+ func ToBalanceInfos(items map[common.Address]*BalanceInfo) []*BalanceInfo

+ type BlockBalance struct

+ Balance []*BalanceInfo

+ func (s *BlockBalance) ToMap() map[common.Address]*BalanceInfo

+ type BlockContext struct

+ BlockNumber *big.Int

+ CanTransfer CanTransferFunc

+ Coinbase common.Address

+ Difficulty *big.Int

+ GasLimit uint64

+ GetHash GetHashFunc

+ Time *big.Int

+ Transfer TransferFunc

+ type CallContext interface

+ Call func(env *EVM, me ContractRef, addr common.Address, data []byte, ...) ([]byte, error)

+ CallCode func(env *EVM, me ContractRef, addr common.Address, data []byte, ...) ([]byte, error)

+ Create func(env *EVM, me ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error)

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

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

+ type ChainReward struct

+ CoinBase *RewardInfo

+ Height uint64

+ St uint64

+ func CloneChainReward(reward *ChainReward) *ChainReward

+ func NewChainReward(height, tt uint64, coin *RewardInfo, fruits []*RewardInfo, ...) *ChainReward

+ func (s *ChainReward) CoinRewardInfo() map[string]interface{}

+ func (s *ChainReward) RelayerRewardInfo() map[string]interface{}

+ type Config struct

+ Debug bool

+ EVMInterpreter string

+ EWASMInterpreter string

+ EnablePreimageRecording bool

+ ExtraEips []int

+ JumpTable [256]*operation

+ NoRecursion bool

+ Tracer Tracer

+ type Contract struct

+ CallerAddress common.Address

+ Code []byte

+ CodeAddr *common.Address

+ CodeHash common.Hash

+ Gas uint64

+ Input []byte

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

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

+ func (c *Contract) AsDelegate() *Contract

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

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

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

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

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

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

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

+ type ContractRef interface

+ Address func() common.Address

+ type EVM struct

+ Context BlockContext

+ StateDB StateDB

+ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, ...) *EVM

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

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

+ func (evm *EVM) Cancel()

+ func (evm *EVM) Cancelled() bool

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

+ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)

+ func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, ...) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)

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

+ func (evm *EVM) Interpreter() Interpreter

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

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

+ type EVMInterpreter struct

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

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

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

+ type EpochIDInfo struct

+ BeginHeight uint64

+ EndHeight uint64

+ EpochID uint64

+ func GetEpochFromHeight(hh uint64) *EpochIDInfo

+ func GetEpochFromID(eid uint64) *EpochIDInfo

+ func GetEpochFromRange(begin, end uint64) []*EpochIDInfo

+ func GetFirstEpoch() *EpochIDInfo

+ func GetPreFirstEpoch() *EpochIDInfo

+ func (e *EpochIDInfo) String() string

+ type ErrInvalidOpCode struct

+ func (e *ErrInvalidOpCode) Error() string

+ type ErrStackOverflow struct

+ func (e *ErrStackOverflow) Error() string

+ type ErrStackUnderflow struct

+ func (e *ErrStackUnderflow) Error() string

+ type FineItem struct

+ Amount *big.Int

+ EpochID uint64

+ Height *big.Int

+ type GetHashFunc func(uint64) common.Hash

+ type HeaderStore struct

+ func CloneHeaderStore(src *HeaderStore) (dst *HeaderStore, err error)

+ func NewHeaderStore() *HeaderStore

+ func (h *HeaderStore) AddEpochReward(epochID uint64, reward *big.Int)

+ func (h *HeaderStore) AddSyncTimes(epochID, amount uint64, relayer common.Address)

+ func (h *HeaderStore) CalcReward(epochID uint64, allAmount *big.Int) map[common.Address]*big.Int

+ func (h *HeaderStore) DecodeRLP(s *rlp.Stream) error

+ func (h *HeaderStore) EncodeRLP(w io.Writer) error

+ func (h *HeaderStore) GetEpochReward(epochID uint64) *big.Int

+ func (h *HeaderStore) GetReceiveTimes(height uint64) uint64

+ func (h *HeaderStore) GetSortedRelayers(epochID uint64) []common.Address

+ func (h *HeaderStore) IncrReceiveTimes(height uint64)

+ func (h *HeaderStore) Load(state StateDB, address common.Address) (err error)

+ func (h *HeaderStore) LoadReward(epochID uint64, relayer common.Address) *big.Int

+ func (h *HeaderStore) LoadSyncTimes(epochID uint64, relayer common.Address) uint64

+ func (h *HeaderStore) SetEpoch2reward(epochID uint64)

+ func (h *HeaderStore) Store(state StateDB, address common.Address) error

+ func (h *HeaderStore) StoreReward(epochID uint64, relayer common.Address, reward *big.Int)

+ type HeaderStoreCache struct

+ Cache *lru.Cache

+ type Interpreter interface

+ CanRun func([]byte) bool

+ Run func(contract *Contract, input []byte, static bool) ([]byte, error)

+ type JSONLogger struct

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

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

+ func (l *JSONLogger) CaptureFault(*EVM, uint64, OpCode, uint64, uint64, *ScopeContext, int, error)

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

+ func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

+ type JumpTable [256]*operation

+ type LockValue struct

+ Amount string

+ EpochID uint64

+ Height *big.Int

+ Locked bool

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

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

+ type LockedAsset struct

+ Address common.Address

+ LockValue []*LockValue

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

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

+ type LockedItem struct

+ Amount *big.Int

+ Locked bool

+ type LogConfig struct

+ Debug bool

+ DisableMemory bool

+ DisableReturnData bool

+ DisableStack bool

+ DisableStorage bool

+ Limit int

+ Overrides *params.ChainConfig

+ type Memory struct

+ func NewMemory() *Memory

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

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

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

+ func (m *Memory) Len() int

+ func (m *Memory) Print()

+ func (m *Memory) Resize(size uint64)

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

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

+ type OpCode byte

+ const ADD

+ const ADDMOD

+ const ADDRESS

+ const AND

+ const BALANCE

+ const BLOCKHASH

+ const BYTE

+ const CALL

+ const CALLCODE

+ const CALLDATACOPY

+ const CALLDATALOAD

+ const CALLDATASIZE

+ const CALLER

+ const CALLVALUE

+ const CHAINID

+ const CODECOPY

+ const CODESIZE

+ const COINBASE

+ const CREATE

+ const CREATE2

+ const DELEGATECALL

+ const DIFFICULTY

+ const DIV

+ const DUP

+ const DUP1

+ const DUP10

+ const DUP11

+ const DUP12

+ const DUP13

+ const DUP14

+ const DUP15

+ const DUP16

+ const DUP2

+ const DUP3

+ const DUP4

+ const DUP5

+ const DUP6

+ const DUP7

+ const DUP8

+ const DUP9

+ const EQ

+ const EXP

+ const EXTCODECOPY

+ const EXTCODEHASH

+ const EXTCODESIZE

+ const GAS

+ const GASLIMIT

+ const GASPRICE

+ const GT

+ const ISZERO

+ const JUMP

+ const JUMPDEST

+ const JUMPI

+ const LOG0

+ const LOG1

+ const LOG2

+ const LOG3

+ const LOG4

+ const LT

+ const MLOAD

+ const MOD

+ const MSIZE

+ const MSTORE

+ const MSTORE8

+ const MUL

+ const MULMOD

+ const NOT

+ const NUMBER

+ const OR

+ const ORIGIN

+ const PC

+ const POP

+ const PUSH

+ const PUSH1

+ const PUSH10

+ const PUSH11

+ const PUSH12

+ const PUSH13

+ const PUSH14

+ const PUSH15

+ const PUSH16

+ const PUSH17

+ const PUSH18

+ const PUSH19

+ const PUSH2

+ const PUSH20

+ const PUSH21

+ const PUSH22

+ const PUSH23

+ const PUSH24

+ const PUSH25

+ const PUSH26

+ const PUSH27

+ const PUSH28

+ const PUSH29

+ const PUSH3

+ const PUSH30

+ const PUSH31

+ const PUSH32

+ const PUSH4

+ const PUSH5

+ const PUSH6

+ const PUSH7

+ const PUSH8

+ const PUSH9

+ const RETURN

+ const RETURNDATACOPY

+ const RETURNDATASIZE

+ const REVERT

+ const SAR

+ const SDIV

+ const SELFBALANCE

+ const SELFDESTRUCT

+ const SGT

+ const SHA3

+ const SHL

+ const SHR

+ const SIGNEXTEND

+ const SLOAD

+ const SLT

+ const SMOD

+ const SSTORE

+ const STATICCALL

+ const STOP

+ const SUB

+ const SWAP

+ const SWAP1

+ const SWAP10

+ const SWAP11

+ const SWAP12

+ const SWAP13

+ const SWAP14

+ const SWAP15

+ const SWAP16

+ const SWAP2

+ const SWAP3

+ const SWAP4

+ const SWAP5

+ const SWAP6

+ const SWAP7

+ const SWAP8

+ const SWAP9

+ const TIMESTAMP

+ const XOR

+ func StringToOp(str string) OpCode

+ func (op OpCode) IsPush() bool

+ func (op OpCode) IsStaticJump() bool

+ func (op OpCode) String() string

+ type PairRegisterValue struct

+ Amount *big.Int

+ Height *big.Int

+ State uint8

+ type PrecompiledContract interface

+ RequiredGas func(input []byte) uint64

+ Run func(evm *EVM, contract *Contract, input []byte) ([]byte, error)

+ type RedeemItem struct

+ Amount *big.Int

+ EpochID uint64

+ State uint8

+ type Register []*RegisterAccount

+ type RegisterAccount struct

+ Modify *AlterableInfo

+ Relayer bool

+ Unit *registerUnit

+ type RegisterImpl struct

+ func CloneRegisterImpl(ori *RegisterImpl) *RegisterImpl

+ func NewRegisterImpl() *RegisterImpl

+ func (i *RegisterImpl) AppendAmount(height uint64, addr common.Address, val *big.Int) error

+ func (i *RegisterImpl) CancelAccount(curHeight uint64, addr common.Address, amount *big.Int) error

+ func (i *RegisterImpl) Counts() int

+ func (i *RegisterImpl) DecodeRLP(s *rlp.Stream) error

+ func (i *RegisterImpl) DoElections(state StateDB, epochid, height uint64) ([]*RegisterAccount, error)

+ func (i *RegisterImpl) EncodeRLP(w io.Writer) error

+ func (i *RegisterImpl) GetAllRegisterAccount() Register

+ func (i *RegisterImpl) GetBalance(addr common.Address, height uint64) (*big.Int, *big.Int, *big.Int, *big.Int)

+ func (i *RegisterImpl) GetCurrentEpochInfo() ([]*EpochIDInfo, uint64)

+ func (i *RegisterImpl) GetRegisterAccount(epochid uint64, addr common.Address) (*RegisterAccount, error)

+ func (i *RegisterImpl) InsertAccount2(height uint64, addr common.Address, val *big.Int) error

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

+ func (i *RegisterImpl) MakeModifyStateByTip10()

+ func (i *RegisterImpl) RedeemAccount(curHeight uint64, addr common.Address, amount *big.Int) error

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

+ func (i *RegisterImpl) SetCurrentEpoch(eid uint64)

+ func (i *RegisterImpl) Shift(epochid, effectHeight uint64) error

+ func (i *RegisterImpl) Summay() *RegisterSummay

+ func (i *RegisterImpl) UpdateFee(height uint64, addr common.Address, fee *big.Int) error

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

+ type RegisterSummay struct

+ Accounts uint64

+ AllAmount *big.Int

+ Infos []*SummayEpochInfo

+ LastReward uint64

+ type RelayerCache struct

+ Cache *lru.Cache

+ var IC *RelayerCache

+ type RelayerSyncInfo struct

+ Relayer common.Address

+ Reward *big.Int

+ Times uint64

+ type RelayerValue struct

+ Value map[uint64]*big.Int

+ func (s *RelayerValue) ToUnlockedValue(height uint64) *big.Int

+ func (s *RelayerValue) ToUnlockingValue(height uint64) *big.Int

+ type RewardInfo struct

+ Address common.Address

+ Amount *big.Int

+ Register *big.Int

+ func FetchOne(sas []*RewardInfos, addr common.Address) []*RewardInfo

+ func ToRewardInfos1(items map[common.Address]*big.Int) []*RewardInfo

+ func (e *RewardInfo) String() string

+ func (e *RewardInfo) ToJson() map[string]interface{}

+ type RewardInfos struct

+ Items []*RewardInfo

+ func ToRewardInfos2(items map[common.Address]*big.Int) []*RewardInfos

+ func (s *RewardInfos) String() string

+ func (s *RewardInfos) StringToToken() map[string]interface{}

+ type RewardItem struct

+ Amount *big.Int

+ EpochID uint64

+ Height *big.Int

+ type ScopeContext struct

+ Contract *Contract

+ Memory *Memory

+ Stack *Stack

+ type Stack struct

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

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

+ func (st *Stack) Print()

+ type StateDB interface

+ AddAddressToAccessList func(addr common.Address)

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

+ AddLog func(*types.Log)

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

+ AddRefund func(uint64)

+ AddSlotToAccessList func(addr common.Address, slot common.Hash)

+ AddressInAccessList func(addr common.Address) bool

+ CreateAccount func(common.Address)

+ Empty func(common.Address) bool

+ Exist func(common.Address) bool

+ ForEachPOWStorage func(common.Address, func(common.Hash, []byte) bool)

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

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

+ GetCode func(common.Address) []byte

+ GetCodeHash func(common.Address) common.Hash

+ GetCodeSize func(common.Address) int

+ GetCommittedState func(common.Address, common.Hash) common.Hash

+ GetLockedBalance func(addr common.Address) *big.Int

+ GetNonce func(common.Address) uint64

+ GetPOWState func(common.Address, common.Hash) []byte

+ GetRefund func() uint64

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

+ GetUnlockedBalance func(addr common.Address) *big.Int

+ HasSuicided func(common.Address) bool

+ PrepareAccessList func(sender common.Address, dest *common.Address, precompiles []common.Address, ...)

+ RevertToSnapshot func(int)

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

+ SetLockedBalance func(addr common.Address, value *big.Int)

+ SetNonce func(common.Address, uint64)

+ SetPOWState func(common.Address, common.Hash, []byte)

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

+ SlotInAccessList func(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)

+ Snapshot func() int

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

+ SubRefund func(uint64)

+ Suicide func(common.Address) bool

+ type Storage map[common.Hash]common.Hash

+ func (s Storage) Copy() Storage

+ type StructLog struct

+ Depth int

+ Err error

+ Gas uint64

+ GasCost uint64

+ Memory []byte

+ MemorySize int

+ Op OpCode

+ Pc uint64

+ RefundCounter uint64

+ ReturnData []byte

+ Stack []*big.Int

+ Storage map[common.Hash]common.Hash

+ func (s *StructLog) ErrorString() string

+ func (s *StructLog) OpName() string

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

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

+ type StructLogger struct

+ func NewStructLogger(cfg *LogConfig) *StructLogger

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

+ func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

+ func (l *StructLogger) CaptureStart(env *EVM, from common.Address, to common.Address, create bool, input []byte, ...)

+ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

+ func (l *StructLogger) Error() error

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

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

+ type SummayEpochInfo struct

+ AllAmount *big.Int

+ BeginHeight uint64

+ DaCount uint64

+ EndHeight uint64

+ EpochID uint64

+ SaCount uint64

+ type TimedChainReward struct

+ Number uint64

+ Reward *ChainReward

+ St uint64

+ type Tracer interface

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

+ CaptureFault func(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

+ CaptureStart func(env *EVM, from common.Address, to common.Address, create bool, input []byte, ...)

+ CaptureState func(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, ...)

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

+ type TxContext struct

+ GasPrice *big.Int

+ Origin common.Address

v0.1.0

Aug 5, 2021

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