vm

package
v2.2.0+incompatible Latest Latest
Warning

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

Go to latest
Published: Apr 6, 2021 License: GPL-3.0 Imports: 38 Imported by: 35

Documentation

Overview

Package vm implements the Ethereum Virtual Machine.

The vm package implements two EVMs, a byte code VM and a JIT 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. When the BC VM is invoked it invokes the JIT VM in a separate goroutine and compiles the byte code in JIT instructions.

The JIT VM, when invoked, loops around a set of pre-defined instructions until it either runs of gas, causes an internal error, returns or stops.

The JIT optimiser attempts to pre-compile instructions in to chunks or segments such as multiple PUSH operations and static JUMPs. It does this by analysing the opcodes and attempts to match certain regions to known sets. Whenever the optimiser finds said segments it creates a new instruction and replaces the first occurrence in the sequence.

Index

Constants

View Source
const (
	Wancoin10  = "10000000000000000000"  //10
	Wancoin20  = "20000000000000000000"  //20
	Wancoin50  = "50000000000000000000"  //50
	Wancoin100 = "100000000000000000000" //100

	Wancoin200   = "200000000000000000000"   //200
	Wancoin500   = "500000000000000000000"   //500
	Wancoin1000  = "1000000000000000000000"  //1000
	Wancoin5000  = "5000000000000000000000"  //5000
	Wancoin50000 = "50000000000000000000000" //50000

	WanStampdot001 = "1000000000000000" //0.001
	WanStampdot002 = "2000000000000000" //0.002
	WanStampdot005 = "5000000000000000" //0.005

	WanStampdot003 = "3000000000000000" //0.003
	WanStampdot006 = "6000000000000000" //0.006
	WanStampdot009 = "9000000000000000" //0.009

	WanStampdot03 = "30000000000000000"  //0.03
	WanStampdot06 = "60000000000000000"  //0.06
	WanStampdot09 = "90000000000000000"  //0.09
	WanStampdot2  = "200000000000000000" //0.2
	WanStampdot3  = "300000000000000000" //0.3
	WanStampdot5  = "500000000000000000" //0.5

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

	GasReturn       uint64 = 0
	GasStop         uint64 = 0
	GasContractByte uint64 = 200
)
View Source
const (
	// 0xf0 range - closures
	CREATE OpCode = 0xf0 + iota
	CALL
	CALLCODE
	RETURN
	DELEGATECALL
	STATICCALL = 0xfa

	REVERT       = 0xfd
	SELFDESTRUCT = 0xff
)
View Source
const (
	PSMinEpochNum = 7
	PSMaxEpochNum = 90

	PSMaxStake            = 10500000
	PSMinStakeholderStake = 10000
	PSMinValidatorStake   = 50000
	PSMinDelegatorStake   = 100
	PSMinFeeRate          = 0
	PSMaxFeeRate          = 10000
	PSFeeRateStep         = 100
	PSNodeleFeeRate       = 10000
	PSMinPartnerIn        = 10000
	MaxTimeDelegate       = 10
	UpdateDelay           = 3
	QuitDelay             = 3
	JoinDelay             = 2
	PSOutKeyHash          = 700
)
the contract interface described by solidity.
contract stake {
	function stakeIn(bytes memory secPk, bytes memory bn256Pk, uint256 lockEpochs, uint256 feeRate) public payable {}
	function stakeUpdate(address addr, uint256 lockEpochs) public {}
	function stakeUpdateFeeRate(address addr, uint256 feeRate) public {}
	function stakeAppend(address addr) public payable {}
	function partnerIn(address addr, bool renewal) public payable {}
	function delegateIn(address delegateAddress) public payable {}
	function delegateOut(address delegateAddress) public {}

	event stakeIn(address indexed sender, address indexed posAddress, uint indexed value, uint256 feeRate, uint256 lockEpoch);
	event stakeAppend(address indexed sender, address indexed posAddress, uint indexed value);
	event stakeUpdate(address indexed sender, address indexed posAddress, uint indexed lockEpoch);
	event delegateIn(address indexed sender, address indexed posAddress, uint indexed value);
	event delegateOut(address indexed sender, address indexed posAddress);
	event stakeUpdateFeeRate(address indexed sender, address indexed posAddress, uint indexed feeRate);
	event partnerIn(address indexed sender, address indexed posAddress, uint indexed value, bool renewal);
}
View Source
const (
	RbDkg1Stage int
	RbDkg1ConfirmStage
	RbDkg2Stage
	RbDkg2ConfirmStage
	RbSignStage
	RbSignConfirmStage
)
View Source
const (
	SlotLeaderStag1 = "slotLeaderStag1"
	SlotLeaderStag2 = "slotLeaderStag2"

	SlotLeaderStag1Indexes = "slotLeaderStag1Indexes"
	SlotLeaderStag2Indexes = "slotLeaderStag2Indexes"
)
View Source
const (
	POLY_CIMMIT_ITEM_LEN = 64
)

Variables

View Source
var (
	ErrMismatchedValue = errors.New("mismatched wancoin value")

	ErrInvalidOTASet = errors.New("invalid OTA mix set")

	ErrOTAReused = errors.New("OTA is reused")

	StampValueSet   = make(map[string]string, 5)
	WanCoinValueSet = make(map[string]string, 10)
)
View Source
var (
	ErrOutOfGas                 = errors.New("out of gas")
	ErrCodeStoreOutOfGas        = errors.New("contract creation code storage out of gas")
	ErrDepth                    = errors.New("max call depth exceeded")
	ErrTraceLimitReached        = errors.New("the number of logs reached the specified limit")
	ErrInsufficientBalance      = errors.New("insufficient balance for transfer")
	ErrContractAddressCollision = errors.New("contract address collision")
	ErrInvalidGasPrice          = errors.New("invalid gas price")
	ErrInvalidPrivacyValue      = errors.New("invalid privacy transaction value")
	ErrInvalidPosValue          = errors.New("invalid pos transaction value")
)
View Source
var (
	ErrUnknown          = errors.New("unknown error")
	ErrInvalidOTAAddr   = errors.New("invalid OTA addrss")
	ErrInvalidOTAAX     = errors.New("invalid OTA AX")
	ErrOTAExistAlready  = errors.New("OTA exist already")
	ErrOTABalanceIsZero = errors.New("OTA balance is 0")
)
View Source
var (
	MinValidatorStake = new(big.Int).Mul(big.NewInt(PSMinValidatorStake), ether)

	StakersInfoStakeOutKeyHash = common.BytesToHash(big.NewInt(PSOutKeyHash).Bytes())
)
View Source
var (
	WanCscPrecompileAddr = common.BytesToAddress([]byte{218})
	StakersInfoAddr      = common.BytesToAddress(big.NewInt(400).Bytes())
	StakingCommonAddr    = common.BytesToAddress(big.NewInt(401).Bytes())
	StakersFeeAddr       = common.BytesToAddress(big.NewInt(402).Bytes())
	StakersMaxFeeAddr    = common.BytesToAddress(big.NewInt(403).Bytes())

	IncentivePrecompileAddr = common.BytesToAddress(big.NewInt(606).Bytes()) //0x25E

	PosControlPrecompileAddr = common.BytesToAddress(big.NewInt(612).Bytes())

	SolEnhancePrecompileAddr = common.BytesToAddress(big.NewInt(616).Bytes())

	// TODO: remove one?
	RandomBeaconPrecompileAddr = randomBeaconPrecompileAddr
	SlotLeaderPrecompileAddr   = slotLeaderPrecompileAddr
)

Precompiled contracts address or Reserved contracts address. Should prevent overwriting to them.

View Source
var (
	ErrEpochID                         = errors.New("EpochID is not valid")
	ErrIllegalSender                   = errors.New("sender is not in epoch leaders ")
	ErrInvalidLocalPublicKey           = errors.New("getLocalPublicKey error, do not found unlock address")
	ErrInvalidPreEpochLeaders          = errors.New("can not found pre epoch leaders return epoch 0")
	ErrInvalidGenesisPk                = errors.New("invalid GenesisPK hex string")
	ErrSlotLeaderGroupNotReady         = errors.New("slot leaders group not ready")
	ErrSlotIDOutOfRange                = errors.New("slot id index out of range")
	ErrPkNotInCurrentEpochLeadersGroup = errors.New("local public key is not in current Epoch leaders")
	ErrInvalidRandom                   = errors.New("get random message error")
	ErrNotOnCurve                      = errors.New("not on curve")
	ErrTx1AndTx2NotConsistent          = errors.New("stageOneMi is not equal sageTwoAlphaPki")
	ErrEpochLeaderNotReady             = errors.New("epoch leaders are not ready")
	ErrNoTx2TransInDB                  = errors.New("tx2 is not in db")
	ErrCollectTxData                   = errors.New("collect tx data error")
	ErrRlpUnpackErr                    = errors.New("RlpUnpackDataForTx error")
	ErrNoTx1TransInDB                  = errors.New("GetStg1StateDbInfo: Found not data of key")
	ErrVerifyStg1Data                  = errors.New("stg1 data get from StateDb verified failed")
	ErrDleqProof                       = errors.New("VerifyDleqProof false")
	ErrInvalidTxLen                    = errors.New("len(mi)==0 or len(alphaPkis) is not right")
	ErrInvalidTx1Range                 = errors.New("slot leader tx1 is not in invalid range")
	ErrInvalidTx2Range                 = errors.New("slot leader tx2 is not in invalid range")
	ErrInvalidProof                    = errors.New("proof is bigZero")
	ErrPowRcvPosTrans                  = errors.New("pow phase receive pos protocol trans")
	ErrDuplicateStg1                   = errors.New("stage one transaction exists")
	ErrDuplicateStg2                   = errors.New("stage two transaction exists")
)
View Source
var (

	// invalid ring signed info
	ErrInvalidRingSigned = errors.New("invalid ring signed info")
)
View Source
var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{

	WanCscPrecompileAddr:     &PosStaking{},
	PosControlPrecompileAddr: &PosControl{},

	SolEnhancePrecompileAddr: &SolEnhance{},
	// contains filtered or unexported fields
}

PrecompiledContractsByzantium contains the default set of pre-compiled Ethereum contracts used in the Byzantium release.

View Source
var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract{
	// contains filtered or unexported fields
}

PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum contracts used in the Frontier and Homestead releases.

View Source
var UpgradeWhiteEpochLeaderDefault = UpgradeWhiteEpochLeaderParam{
	EpochId: big.NewInt(0),
	WlIndex: big.NewInt(0),
	WlCount: big.NewInt(26),
}

Functions

func AddOTAIfNotExist

func AddOTAIfNotExist(statedb StateDB, balance *big.Int, otaWanAddr []byte) (bool, error)

AddOTAIfNotExist storage ota info if doesn't exist already.

func AddOTAImage

func AddOTAImage(statedb StateDB, otaImage []byte, value []byte) error

AddOTAImage storage ota image key. Overwrite if exist already.

func BatCheckOTAExist

func BatCheckOTAExist(statedb StateDB, otaLongAddrs [][]byte) (exist bool, balance *big.Int, unexistOta []byte, err error)

func ByteSliceToUInt

func ByteSliceToUInt(bs []byte) uint64

func ByteSliceToUInt32

func ByteSliceToUInt32(bs []byte) uint32

func BytesToCij

func BytesToCij(d *[][]byte) ([]*bn256.G2, error)

storage parse functions

func BytesToEncryptShare

func BytesToEncryptShare(d *[][]byte) ([]*bn256.G1, error)

func CalLocktimeWeight

func CalLocktimeWeight(lockEpoch uint64) uint64

the weight of 7 epoch: a + 7*b ~= 1000 the weight of 90 epoch: a + 90*b ~= 1500 the time of maxEpoch/minEpoch is 1.5 so the a=960, b=6. thus, weight of 7 epoch is 960+7*6=1002 the weight of 90 epoch is 960+90*6 = 1500 the time is 1500/1002, about 1.5

func CheckOTAAXExist added in v1.0.3

func CheckOTAAXExist(statedb StateDB, otaAX []byte) (exist bool, balance *big.Int, err error)

ChechOTAExist checks the OTA exist or not.

In order to avoid additional ota have conflict with existing, even if AX exist in balance storage already, will return true.

func CheckOTAImageExist

func CheckOTAImageExist(statedb StateDB, otaImage []byte) (bool, []byte, error)

CheckOTAImageExist checks ota image key exist already or not

func CheckOTALongAddrExist added in v1.0.3

func CheckOTALongAddrExist(statedb StateDB, otaLongAddr []byte) (exist bool, balance *big.Int, err error)

func DecodeRingSignOut

func DecodeRingSignOut(s string) (error, []*ecdsa.PublicKey, *ecdsa.PublicKey, []*big.Int, []*big.Int)

func GetAXFromWanAddr

func GetAXFromWanAddr(otaWanAddr []byte) ([]byte, error)

GetAXFromWanAddr retrieve ota AX from ota WanAddr

func GetCji

func GetCji(db StateDB, epochId uint64, proposerId uint32) ([]*bn256.G2, error)

func GetDkg1Id

func GetDkg1Id() []byte

public get methods

func GetDkg2Id

func GetDkg2Id() []byte

func GetEncryptShare

func GetEncryptShare(db StateDB, epochId uint64, proposerId uint32) ([]*bn256.G1, error)

get encrypt share

func GetInfo

func GetInfo(statedb StateDB, listAddr common.Address, pubHash common.Hash) ([]byte, error)

get stored info

func GetOTAInfoFromAX

func GetOTAInfoFromAX(statedb StateDB, otaAX []byte) (otaWanAddr []byte, balance *big.Int, err error)

GetOTAInfoFromAX retrieve ota info, include balance and WanAddr

func GetOTASet

func GetOTASet(statedb StateDB, otaAX []byte, setNum int) (otaWanAddrs [][]byte, balance *big.Int, err error)

GetOTASet retrieve the setNum of same balance OTA address of the input OTA setting by otaAX, and ota balance. Rules:

1: The result can't contain otaAX self;
2: The result can't contain duplicate items;
3: No ota exist in the mpt, return error;
4: OTA total count in the mpt less or equal to the setNum, return error(returned set must
   can't contain otaAX self, so need more exist ota in mpt);
5: If find invalid ota wanaddr, return error;
6: Travel the ota mpt.Record loop exist ota cumulative times as loopTimes.
   Generate a random number as rnd.
   If loopTimes%rnd == 0, collect current exist ota to result set and update the rnd.
   Loop checking exist ota and loop traveling ota mpt, untile collect enough ota or find error.

func GetOtaBalanceFromAX

func GetOtaBalanceFromAX(statedb StateDB, otaAX []byte) (*big.Int, error)

GetOtaBalanceFromAX retrieve ota balance from ota AX

func GetPolynomialX

func GetPolynomialX(pk *bn256.G1, proposerId uint32) []byte

func GetR

func GetR(db StateDB, epochId uint64) *big.Int

get r of one epoch, if not exist return r in epoch 0

func GetRBAddress

func GetRBAddress() common.Address

func GetRBKeyHash

func GetRBKeyHash(kind []byte, epochId uint64, proposerId uint32) *common.Hash

get key hash

func GetRBM

func GetRBM(db StateDB, epochId uint64) ([]byte, error)

get M

func GetRBRKeyHash

func GetRBRKeyHash(epochId uint64) *common.Hash

get r's key hash

func GetRBStage

func GetRBStage(slotId uint64) (int, int, int)

return:

current stage index;
elapsed slots number of current stage;
left slots number of current stage;

func GetSigShareId

func GetSigShareId() []byte

func GetSlStage

func GetSlStage(slotId uint64) uint64

func GetSlotLeaderSCAddress

func GetSlotLeaderSCAddress() common.Address

GetSlotLeaderSCAddress can get the precompile contract address

func GetSlotLeaderScAbiString

func GetSlotLeaderScAbiString() string

GetSlotLeaderScAbiString can get the precompile contract Define string

func GetSlotLeaderStage1KeyHash

func GetSlotLeaderStage1KeyHash(epochID, selfIndex []byte) common.Hash

func GetSlotLeaderStage2IndexesKeyHash

func GetSlotLeaderStage2IndexesKeyHash(epochID []byte) common.Hash

func GetSlotLeaderStage2KeyHash

func GetSlotLeaderStage2KeyHash(epochID, selfIndex []byte) common.Hash

GetSlotLeaderStage2KeyHash use to get SlotLeader Stage 1 KeyHash by epochid and selfindex

func GetSlotScCallTimes

func GetSlotScCallTimes(epochID uint64) uint64

GetSlotScCallTimes can get this precompile contract called times

func GetStage1FunctionID

func GetStage1FunctionID(abiString string) ([4]byte, error)

func GetStage2FunctionID

func GetStage2FunctionID(abiString string) ([4]byte, error)

func GetStage2TxAlphaPki

func GetStage2TxAlphaPki(stateDb StateDB, epochID uint64, selfIndex uint64) (alphaPkis []*ecdsa.PublicKey,
	proofs []*big.Int, err error)

func GetStakeInKeyHash

func GetStakeInKeyHash(address common.Address) common.Hash

func GetStateR

func GetStateR(db StateDB, epochId uint64) *big.Int

get r of one epoch

func GetStg1StateDbInfo

func GetStg1StateDbInfo(stateDb StateDB, epochID uint64, index uint64) (mi []byte, err error)

func GetSupportStampOTABalances

func GetSupportStampOTABalances() []*big.Int

func GetSupportWanCoinOTABalances

func GetSupportWanCoinOTABalances() []*big.Int

func GetUnspendOTATotalBalance added in v1.0.3

func GetUnspendOTATotalBalance(statedb StateDB) (*big.Int, error)

func GetValidDkg1Cnt

func GetValidDkg1Cnt(db StateDB, epochId uint64) uint64

func GetValidDkg2Cnt

func GetValidDkg2Cnt(db StateDB, epochId uint64) uint64

func GetValidSMA1Cnt

func GetValidSMA1Cnt(db StateDB, epochId uint64) uint64

func GetValidSMA2Cnt

func GetValidSMA2Cnt(db StateDB, epochId uint64) uint64

func GetValidSigCnt

func GetValidSigCnt(db StateDB, epochId uint64) uint64

func InEpochLeadersOrNotByAddress

func InEpochLeadersOrNotByAddress(epochID uint64, selfIndex uint64, senderAddress common.Address) bool

func IsAXPointToWanAddr

func IsAXPointToWanAddr(AX []byte, otaWanAddr []byte) bool

IsAXPointToWanAddr check whether AX point to otaWanAddr or not

func IsJoinDKG2

func IsJoinDKG2(db StateDB, epochId uint64, proposerId uint32) bool

func IsPosPrecompiledAddr

func IsPosPrecompiledAddr(addr *common.Address) bool

func IsRBActive

func IsRBActive(db StateDB, epochId uint64, proposerId uint32) bool

more public functions

active: participate in all stages --- dkg1 dkg2 sign

func NewByzantiumInstructionSet

func NewByzantiumInstructionSet() [256]operation

NewByzantiumInstructionSet returns the frontier, homestead and byzantium instructions.

func NewFrontierInstructionSet

func NewFrontierInstructionSet() [256]operation

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

func NewHomesteadInstructionSet

func NewHomesteadInstructionSet() [256]operation

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

func NoopCanTransfer

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

func NoopTransfer

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

func OTABalance2ContractAddr

func OTABalance2ContractAddr(balance *big.Int) common.Address

OTABalance2ContractAddr convert ota balance to ota storage address

1 wancoin --> (bigint)1000000000000000000 --> "0x0000000000000000000001000000000000000000"

func PackStage1Data

func PackStage1Data(input []byte, abiString string) ([]byte, error)

PackStage1Data can pack stage1 data into abi []byte for tx payload

func RlpGetStage1IDFromTx

func RlpGetStage1IDFromTx(input []byte) (epochIDBuf []byte, selfIndexBuf []byte, err error)

RlpGetStage1IDFromTx

func RlpGetStage2IDFromTx

func RlpGetStage2IDFromTx(input []byte) (epochIDBuf []byte, selfIndexBuf []byte, err error)

func RlpPackStage1DataForTx

func RlpPackStage1DataForTx(epochID uint64, selfIndex uint64, mi *ecdsa.PublicKey, abiString string) ([]byte, error)

RlpPackStage1DataForTx

func RlpPackStage2DataForTx

func RlpPackStage2DataForTx(epochID uint64, selfIndex uint64, selfPK *ecdsa.PublicKey, alphaPki []*ecdsa.PublicKey,
	proof []*big.Int, abiString string) ([]byte, error)

func RlpUnpackStage1DataForTx

func RlpUnpackStage1DataForTx(input []byte) (epochID uint64, selfIndex uint64, mi *ecdsa.PublicKey, err error)

RlpUnpackStage1DataForTx

func RlpUnpackStage2DataForTx

func RlpUnpackStage2DataForTx(input []byte) (epochID uint64, selfIndex uint64, selfPK *ecdsa.PublicKey,
	alphaPki []*ecdsa.PublicKey, proof []*big.Int, err error)

func RunPrecompiledContract

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

RunPrecompiledContract runs and evaluates the output of a precompiled contract.

func SetDKGData

func SetDKGData(epochId uint64, proposerId uint, data *DKG) error

func SetOtaBalanceToAX

func SetOtaBalanceToAX(statedb StateDB, otaAX []byte, balance *big.Int) error

SetOtaBalanceToAX set ota balance as 'balance'. Overwrite if ota balance exist already.

func SetSIGData

func SetSIGData(epochId uint64, proposerId uint, data *SIG) error

func StakeoutIsFinished

func StakeoutIsFinished(stateDb *state.StateDB, epochID uint64) bool

func StakeoutSetEpoch

func StakeoutSetEpoch(stateDb *state.StateDB, epochID uint64)

func StoreInfo

func StoreInfo(statedb StateDB, listAddr common.Address, pubHash common.Hash, info []byte) error

store information to the list

func UInt32ToByteSlice

func UInt32ToByteSlice(num uint32) []byte

func UIntToByteSlice

func UIntToByteSlice(num uint64) []byte

help function for serial

func UpdateInfo

func UpdateInfo(statedb StateDB, listAddr common.Address, pubHash common.Hash, info []byte) error

store information to the list

func ValidPosELTx

func ValidPosELTx(stateDB StateDB, from common.Address, payload []byte) error

valid common data

func ValidPosRBTx

func ValidPosRBTx(stateDB StateDB, from common.Address, payload []byte) error

params or gas check functions

func WriteLogs

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

WriteLogs writes vm logs in a readable format to the given writer

func WriteTrace

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

WriteTrace writes a formatted trace to the given writer

Types

type AccountRef

type AccountRef common.Address

AccountRef implements ContractRef.

Account references are used during EVM initialisation and it's primary use is to fetch addresses. Removing this object proves difficult because of the cached jump destinations which are fetched from the parent contract (i.e. the caller), which is a ContractRef.

func (AccountRef) Address

func (ar AccountRef) Address() common.Address

Address casts AccountRef to a Address

type CallContext

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

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

type CanTransferFunc

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

type ClientIncentive

type ClientIncentive struct {
	ValidatorAddr common.Address
	WalletAddr    common.Address
	Incentive     *big.Int
}

type ClientInfo

type ClientInfo struct {
	Address     common.Address
	Amount      *big.Int
	StakeAmount *big.Int //staking wan value
	QuitEpoch   uint64
}

type ClientProbability

type ClientProbability struct {
	ValidatorAddr common.Address
	WalletAddr    common.Address
	Probability   *big.Int
}

type Config

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

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

	Args []byte

	DelegateCall bool
	// contains filtered or unexported fields
}

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

func NewContract

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

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

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 (self *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte)

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

func (*Contract) SetCode

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

SetCode sets the code to the contract

func (*Contract) UseGas

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

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

func (*Contract) Value

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

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

type ContractRef

type ContractRef interface {
	Address() common.Address
}

ContractRef is a reference to the contract's backing object

type DKG

type DKG struct {
}

func GetDKGData

func GetDKGData(epochId uint64, proposerId uint) (*DKG, error)

type DelegateParam

type DelegateParam struct {
	DelegateAddress common.Address //delegation’s address
}

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 retutrns a new EVM . The returned EVM is not thread safe and should only ever be used *once*.

func (*EVM) Call

func (evm *EVM) Call(caller ContractRef, 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 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) ChainConfig

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

ChainConfig returns the evmironment's chain configuration

func (*EVM) Create

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

Create creates a new contract using code as deployment code.

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

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

func (*GetOTASetEnv) IsSetFull

func (env *GetOTASetEnv) IsSetFull() bool

func (*GetOTASetEnv) OTAInSet

func (env *GetOTASetEnv) OTAInSet(ota []byte) bool

func (*GetOTASetEnv) RandomSelOTA

func (env *GetOTASetEnv) RandomSelOTA(value []byte) bool

func (*GetOTASetEnv) UpdateRnd

func (env *GetOTASetEnv) UpdateRnd()

type Interpreter

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

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

func NewInterpreter

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

NewInterpreter returns a new instance of the Interpreter.

func (*Interpreter) Run

func (in *Interpreter) Run(snapshot int, 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. No error specific checks should be handled to reduce complexity and errors further down the in.

type Leader

type Leader struct {
	Type      uint8          `json:"type"`
	SecAddr   common.Address `json:"secAddr"`
	PubSec256 []byte         `json:"pubSec256"`
	PubBn256  []byte         `json:"pubBn256"`
}

public helper structures

type LogConfig

type LogConfig struct {
	DisableMemory  bool // disable memory capture
	DisableStack   bool // disable stack capture
	DisableStorage bool // disable storage capture
	FullStorage    bool // show full storage (slow)
	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

func (*Memory) Data

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

Data returns the backing slice

func (*Memory) Get

func (self *Memory) Get(offset, size int64) (cpy []byte)

Get returns offset + size as a new slice

func (*Memory) GetPtr

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

GetPtr returns the offset + size

func (*Memory) Len

func (m *Memory) Len() int

Len returns the length of the backing slice

func (*Memory) Print

func (m *Memory) Print()

func (*Memory) Resize

func (m *Memory) Resize(size uint64)

Resize resizes the memory to size

func (*Memory) Set

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

Set sets offset + size to value

type NoopEVMCallContext

type NoopEVMCallContext struct{}

func (NoopEVMCallContext) Call

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

func (NoopEVMCallContext) CallCode

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

func (NoopEVMCallContext) Create

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

func (NoopEVMCallContext) DelegateCall

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

type NoopStateDB

type NoopStateDB struct{}

func (NoopStateDB) AddBalance

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

func (NoopStateDB) AddLog

func (NoopStateDB) AddLog(*types.Log)

func (NoopStateDB) AddPreimage

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

func (NoopStateDB) AddRefund

func (NoopStateDB) AddRefund(*big.Int)

func (NoopStateDB) CreateAccount

func (NoopStateDB) CreateAccount(common.Address)

func (NoopStateDB) Empty

func (NoopStateDB) Empty(common.Address) bool

func (NoopStateDB) Exist

func (NoopStateDB) Exist(common.Address) bool

func (NoopStateDB) ForEachStorage

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

func (NoopStateDB) ForEachStorageByteArray

func (NoopStateDB) ForEachStorageByteArray(common.Address, func(common.Hash, []byte) bool)

func (NoopStateDB) GetBalance

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

func (NoopStateDB) GetCode

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

func (NoopStateDB) GetCodeHash

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

func (NoopStateDB) GetCodeSize

func (NoopStateDB) GetCodeSize(common.Address) int

func (NoopStateDB) GetNonce

func (NoopStateDB) GetNonce(common.Address) uint64

func (NoopStateDB) GetRefund

func (NoopStateDB) GetRefund() *big.Int

func (NoopStateDB) GetState

func (NoopStateDB) GetStateByteArray

func (NoopStateDB) GetStateByteArray(addr common.Address, hs common.Hash) []byte

func (NoopStateDB) HasSuicided

func (NoopStateDB) HasSuicided(common.Address) bool

func (NoopStateDB) RevertToSnapshot

func (NoopStateDB) RevertToSnapshot(int)

func (NoopStateDB) SetCode

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

func (NoopStateDB) SetNonce

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

func (NoopStateDB) SetState

func (NoopStateDB) SetStateByteArray

func (NoopStateDB) SetStateByteArray(common.Address, common.Hash, []byte)

func (NoopStateDB) Snapshot

func (NoopStateDB) Snapshot() int

func (NoopStateDB) SubBalance

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

func (NoopStateDB) Suicide

func (NoopStateDB) Suicide(common.Address) bool

type OpCode

type OpCode byte

OpCode is an EVM opcode

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

	SHA3 = 0x20
)
const (
	// 0x30 range - closure state
	ADDRESS OpCode = 0x30 + iota
	BALANCE
	ORIGIN
	CALLER
	CALLVALUE
	CALLDATALOAD
	CALLDATASIZE
	CALLDATACOPY
	CODESIZE
	CODECOPY
	GASPRICE
	EXTCODESIZE
	EXTCODECOPY
	RETURNDATASIZE
	RETURNDATACOPY
)
const (
	// 0x40 range - block operations
	BLOCKHASH OpCode = 0x40 + iota
	COINBASE
	TIMESTAMP
	NUMBER
	DIFFICULTY
	GASLIMIT
)
const (
	// 0x50 range - 'storage' and execution
	POP OpCode = 0x50 + iota
	MLOAD
	MSTORE
	MSTORE8
	SLOAD
	SSTORE
	JUMP
	JUMPI
	PC
	MSIZE
	GAS
	JUMPDEST
)
const (
	// 0x60 range
	PUSH1 OpCode = 0x60 + iota
	PUSH2
	PUSH3
	PUSH4
	PUSH5
	PUSH6
	PUSH7
	PUSH8
	PUSH9
	PUSH10
	PUSH11
	PUSH12
	PUSH13
	PUSH14
	PUSH15
	PUSH16
	PUSH17
	PUSH18
	PUSH19
	PUSH20
	PUSH21
	PUSH22
	PUSH23
	PUSH24
	PUSH25
	PUSH26
	PUSH27
	PUSH28
	PUSH29
	PUSH30
	PUSH31
	PUSH32
	DUP1
	DUP2
	DUP3
	DUP4
	DUP5
	DUP6
	DUP7
	DUP8
	DUP9
	DUP10
	DUP11
	DUP12
	DUP13
	DUP14
	DUP15
	DUP16
	SWAP1
	SWAP2
	SWAP3
	SWAP4
	SWAP5
	SWAP6
	SWAP7
	SWAP8
	SWAP9
	SWAP10
	SWAP11
	SWAP12
	SWAP13
	SWAP14
	SWAP15
	SWAP16
)
const (
	LOG0 OpCode = 0xa0 + iota
	LOG1
	LOG2
	LOG3
	LOG4
)
const (
	PUSH OpCode = 0xb0 + iota
	DUP
	SWAP
)

unofficial opcodes used for parsing

func StringToOp

func StringToOp(str string) OpCode

func (OpCode) IsPush

func (op OpCode) IsPush() bool

func (OpCode) IsStaticJump

func (op OpCode) IsStaticJump() bool

func (OpCode) String

func (o OpCode) String() string

type PartnerInParam

type PartnerInParam struct {
	Addr    common.Address //stakeholder’s bn256 pairing public key
	Renewal bool
}

type PartnerInfo

type PartnerInfo struct {
	Address      common.Address
	Amount       *big.Int
	StakeAmount  *big.Int //staking wan value
	Renewal      bool
	LockEpochs   uint64
	StakingEpoch uint64
}

type PosControl

type PosControl struct {
}

func (*PosControl) RequiredGas

func (p *PosControl) RequiredGas(input []byte) uint64

contract interfaces

func (*PosControl) Run

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

func (*PosControl) ValidTx

func (p *PosControl) ValidTx(stateDB StateDB, signer types.Signer, tx *types.Transaction) error

type PosStaking

type PosStaking struct {
}

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

pos staking contract

func (*PosStaking) DelegateIn

func (p *PosStaking) DelegateIn(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

one wants to choose a delegation to join the pos

func (*PosStaking) DelegateOut

func (p *PosStaking) DelegateOut(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

func (*PosStaking) PartnerIn

func (p *PosStaking) PartnerIn(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

func (*PosStaking) RequiredGas

func (p *PosStaking) RequiredGas(input []byte) uint64

contract interfaces

func (*PosStaking) Run

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

func (*PosStaking) StakeAppend

func (p *PosStaking) StakeAppend(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

func (*PosStaking) StakeIn

func (p *PosStaking) StakeIn(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

func (*PosStaking) StakeRegister

func (p *PosStaking) StakeRegister(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

func (*PosStaking) StakeUpdate

func (p *PosStaking) StakeUpdate(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

func (*PosStaking) StakeUpdateFeeRate

func (p *PosStaking) StakeUpdateFeeRate(payload []byte, contract *Contract, evm *EVM) ([]byte, error)

func (*PosStaking) ValidTx

func (p *PosStaking) ValidTx(stateDB StateDB, signer types.Signer, tx *types.Transaction) error

type PrecompiledContract

type PrecompiledContract interface {
	RequiredGas(input []byte) uint64                                // RequiredPrice calculates the contract gas use
	Run(input []byte, contract *Contract, evm *EVM) ([]byte, error) // Run runs the precompiled contract
	ValidTx(stateDB StateDB, signer types.Signer, tx *types.Transaction) 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.

type RandomBeaconContract

type RandomBeaconContract struct {
}

One Epoch has 12k slots, random beacon protocol is used to generate a random r, which will be used to generate next epoch leaders and slot leaders. Random beacon protocol has 3 stages --- dkg1 (in 1k,2k slots), dkg2 (in 4k,5k slots), sigShare (in 8k, 9k slots)

func (*RandomBeaconContract) RequiredGas

func (c *RandomBeaconContract) RequiredGas(input []byte) uint64

contract interface

func (*RandomBeaconContract) Run

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

func (*RandomBeaconContract) ValidTx

func (c *RandomBeaconContract) ValidTx(stateDB StateDB, signer types.Signer, tx *types.Transaction) error

type RbCijDataCollector

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

type RbDKG1FlatTxPayload

type RbDKG1FlatTxPayload struct {
	EpochId    uint64
	ProposerId uint32
	// 128 --
	Commit [][]byte
}

structures for params

func Dkg1ToDkg1Flat

func Dkg1ToDkg1Flat(d *RbDKG1TxPayload) *RbDKG1FlatTxPayload

type RbDKG1TxPayload

type RbDKG1TxPayload struct {
	EpochId    uint64
	ProposerId uint32
	Commit     []*bn256.G2
}

params bytes fields to object

func Dkg1FlatToDkg1

func Dkg1FlatToDkg1(d *RbDKG1FlatTxPayload) (*RbDKG1TxPayload, error)

params bytes fields convert functions

type RbDKG2FlatTxPayload

type RbDKG2FlatTxPayload struct {
	EpochId    uint64
	ProposerId uint32
	// encrypt share
	EnShare [][]byte
	Proof   []rbselection.DLEQproofFlat
}

func Dkg2ToDkg2Flat

func Dkg2ToDkg2Flat(d *RbDKG2TxPayload) *RbDKG2FlatTxPayload

type RbDKG2TxPayload

type RbDKG2TxPayload struct {
	EpochId    uint64
	ProposerId uint32
	// encrypt share
	EnShare []*bn256.G1
	Proof   []rbselection.DLEQproof
}

func Dkg2FlatToDkg2

func Dkg2FlatToDkg2(d *RbDKG2FlatTxPayload) (*RbDKG2TxPayload, error)

type RbDKGTxPayloadPure

type RbDKGTxPayloadPure struct {
	EpochId    uint64
	ProposerId uint32
	EnShare    []*bn256.G1
	Commit     []*bn256.G2
}

storage structures

type RbSIGDataCollector

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

type RbSIGTxPayload

type RbSIGTxPayload struct {
	EpochId    uint64
	ProposerId uint32
	GSignShare *bn256.G1
}

func GetSig

func GetSig(db StateDB, epochId uint64, proposerId uint32) (*RbSIGTxPayload, error)

get sig of one epoch, stored in "sigShare" function

type RingSignInfo

type RingSignInfo struct {
	PublicKeys []*ecdsa.PublicKey
	KeyImage   *ecdsa.PublicKey
	W_Random   []*big.Int
	Q_Random   []*big.Int
	OTABalance *big.Int
}

func FetchRingSignInfo

func FetchRingSignInfo(stateDB StateDB, hashInput []byte, ringSignedStr string) (info *RingSignInfo, err error)

type SIG

type SIG struct {
}

func GetSIGData

func GetSIGData(epochId uint64, proposerId uint) (*SIG, error)

type SolEnhance

type SolEnhance struct {
}

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

func (*SolEnhance) EvalByPolyG

func (s *SolEnhance) EvalByPolyG(pks []*ecdsa.PublicKey, degree int, x *big.Int) (*ecdsa.PublicKey, error)

func (*SolEnhance) RequiredGas

func (s *SolEnhance) RequiredGas(input []byte) uint64

contract interfaces

func (*SolEnhance) Run

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

func (*SolEnhance) ValidTx

func (s *SolEnhance) ValidTx(stateDB StateDB, signer types.Signer, tx *types.Transaction) error

type Stack

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

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

func (*Stack) Back

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

Back returns the n'th item in stack

func (*Stack) Data

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

func (*Stack) Print

func (st *Stack) Print()

type StakeInParam

type StakeInParam struct {
	SecPk      []byte   //stakeholder’s original public key
	Bn256Pk    []byte   //stakeholder’s bn256 pairing public key
	LockEpochs *big.Int //lock time which is input by user
	FeeRate    *big.Int
	// contains filtered or unexported fields
}

param structures

type StakeRegisterParam

type StakeRegisterParam struct {
	StakeInParam
	MaxFeeRate *big.Int
}

type StakeUpdateParam

type StakeUpdateParam struct {
	Addr       common.Address //stakeholder’s bn256 pairing public key
	LockEpochs *big.Int       //lock time which is input by user
}

type StakerInfo

type StakerInfo struct {
	Address   common.Address
	PubSec256 []byte //stakeholder’s wan public key
	PubBn256  []byte //stakeholder’s bn256 public key

	Amount         *big.Int //staking wan value
	StakeAmount    *big.Int //staking wan value
	LockEpochs     uint64   //lock time which is input by user. 0 means unexpired.
	NextLockEpochs uint64   //lock time which is input by user. 0 means unexpired.
	From           common.Address

	StakingEpoch uint64 //the first epoch in which stakerHolder might be selected.
	FeeRate      uint64
	//NextFeeRate  uint64
	Clients  []ClientInfo
	Partners []PartnerInfo
}

storage structures

func GetStakersSnap

func GetStakersSnap(stateDb *state.StateDB) []StakerInfo

type StateDB

type StateDB interface {
	CreateAccount(common.Address)

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

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

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

	AddRefund(*big.Int)
	GetRefund() *big.Int

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

	GetStateByteArray(common.Address, common.Hash) []byte
	SetStateByteArray(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 = data.root = dirtyStorage = 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)

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

func (Storage) Copy

func (self Storage) Copy() Storage

type StructLog

type StructLog struct {
	Pc         uint64                      `json:"pc"`
	Op         OpCode                      `json:"op"`
	Gas        uint64                      `json:"gas"`
	GasCost    uint64                      `json:"gasCost"`
	Memory     []byte                      `json:"memory"`
	MemorySize int                         `json:"memSize"`
	Stack      []*big.Int                  `json:"stack"`
	Storage    map[common.Hash]common.Hash `json:"-"`
	Depth      int                         `json:"depth"`
	Err        error                       `json:"error"`
}

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

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

func (*StructLog) OpName

func (s *StructLog) OpName() string

func (*StructLog) UnmarshalJSON

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

type StructLogger

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

StructLogger is an EVM state logger and implements Tracer.

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

func NewStructLogger

func NewStructLogger(cfg *LogConfig) *StructLogger

NewStructLogger returns a new logger

func (*StructLogger) CaptureEnd

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

func (*StructLogger) CaptureState

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

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

CaptureState also tracks SSTORE ops to track dirty values.

func (*StructLogger) StructLogs

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

StructLogs returns a list of captured log entries

type Tracer

type Tracer interface {
	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
	CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error
}

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

type TransferFunc

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

type UpdateFeeRate

type UpdateFeeRate struct {
	ValidatorAddr common.Address
	MaxFeeRate    uint64
	FeeRate       uint64
	ChangedEpoch  uint64
}

type UpdateFeeRateParam

type UpdateFeeRateParam struct {
	Addr    common.Address
	FeeRate *big.Int
}

type UpgradeWhiteEpochLeaderParam

type UpgradeWhiteEpochLeaderParam struct {
	EpochId *big.Int
	WlIndex *big.Int
	WlCount *big.Int
}

func GetEpochWLInfo

func GetEpochWLInfo(stateDb StateDB, epochId uint64) *UpgradeWhiteEpochLeaderParam

type ValidatorInfo

type ValidatorInfo struct {
	TotalProbability *big.Int
	FeeRate          uint64
	ValidatorAddr    common.Address
	WalletAddr       common.Address
	Infos            []ClientProbability // the position 0 is validator and others is delegators.
}

type WhiteInfos

type WhiteInfos []UpgradeWhiteEpochLeaderParam

func GetWlConfig

func GetWlConfig(stateDb StateDB) WhiteInfos

func (WhiteInfos) Len

func (s WhiteInfos) Len() int

func (WhiteInfos) Less

func (s WhiteInfos) Less(i, j int) bool

func (WhiteInfos) Swap

func (s WhiteInfos) Swap(i, j int)

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