models

type AccessList []AccessTuple

type AccessListTx struct {
	ChainID    *big.Int        // destination chain ID
	Nonce      uint64          // nonce of sender account
	GasPrice   *big.Int        // wei per gas
	Gas        uint64          // gas limit
	To         *common.Address `rlp:"nil"` // nil means contract creation
	Value      *big.Int        // wei amount
	Data       []byte          // contract invocation input data
	AccessList AccessList      // EIP-2930 access list
	V, R, S    *big.Int        // signature values
}

type AccessTuple struct {
	Address     common.Address `json:"address"        gencodec:"required"`
	StorageKeys []common.Hash  `json:"storageKeys"    gencodec:"required"`
}

type Account struct {
	Addr            common.Address `json:"address"`         // account address
	Nonce           uint64         `json:"nonce"`           // next transaction nonce
	Balance         *big.Int       `json:"balance"`         // basic currency, never be nil
	LocalCurrency   *big.Int       `json:"localCurrency"`   // local currency (if exist), could be nil
	StorageRoot     []byte         `json:"storageRoot"`     // storage for contract，Trie(key: Hash, value: Hash)
	CodeHash        []byte         `json:"codeHash"`        // hash of contract code
	LongStorageRoot []byte         `json:"longStorageRoot"` // more complex storage for contract, Trie(key: Hash, value: []byte)
}

type AccountDelta struct {
	Addr          common.Address
	Delta         *big.Int // Balance modification
	CurrencyDelta *big.Int // LocalCurrency modification (if has)
}

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

type AccountDeltaTrie struct {
	trie.SmallCombinedTrie
	// contains filtered or unexported fields
}

type AccountState interface {
	Address() common.Address
	GetAccount() *Account
}

type Accounts []*Account

type AttendanceRecord struct {
	Epoch      common.EpochNum // current epoch
	Attendance *big.Int        // Indicates by bit whether the corresponding data block is empty, Attendance.Bit(BlockNum)==1 is normal block and ==0 is empty block
	DataNodes  common.NodeIDs  // List of datanode nodeid in ascending order
	Stats      []int           // Stats of alive data nodes
	// contains filtered or unexported fields
}

type BlockAppendSuccess func(block *BlockEMessage, hashOfHeader []byte) error

type BlockBody struct {
	NextCommittee     *Committee        // election results of the next committee
	NCMsg             []*ElectMessage   // election requests for chains (in main chain)
	DeltaFroms        DeltaFroms        // deltas merged to current shard
	Txs               []*Transaction    // transactions
	TxsPas            []*PubAndSig      // signatures corresponding to packaged transactions
	Deltas            []*AccountDelta   // the delta generated by packaged transactions on current shard needs to be sent to other shards
	Hds               []*BlockSummary   // block summary reported by children chains
	Attendance        *AttendanceRecord // attendance table of the current epoch
	RewardReqs        RewardRequests    // self-proving reward request of each chain received on the main chain
	ElectingResults   ChainElectResults // Since v1.5.0, a list of election results, it's a preelection when Epoch.IsNil()==true, others are local election (not provided at present)
	PreElectings      PreElectings      // Since v1.5.0, the list of preselections in progress, sorted by (expire, chainid)
	NextRealCommittee *Committee        // Since v1.5.0, when election finished, the result will be put into NextCommittee. If the election is failed, the current committee will continue to be used in the next epoch. At this time, the current committee needs to be written into this field, which can be brought with it when reporting.
	SeedFactor        SeedFactor        // Since v2.0.0, random factor of seed
}

type BlockChain interface {
	CurrentBlock() *BlockEMessage
	Append(block *BlockEMessage, validator func(*BlockEMessage) error) (int, []byte, error)
	GetCurrentHeight() common.Height
	GetBlockHash(height common.Height) (*common.Hash, bool)
	GetBlock(height common.Height) (*BlockEMessage, error)
	GetHeader(height common.Height) (*BlockHeader, error)
	GetBlockByHash(hashOfHeader []byte) (*BlockEMessage, error)
	GetBlockTxIndexs(txHash []byte) (*TXIndex, error)
}

type BlockCursor struct {
	Height common.Height
	Hash   []byte
}

type BlockEMessage struct {
	BlockHeader *BlockHeader
	BlockBody   *BlockBody
	BlockPass   PubAndSigs
}

type BlockHeader struct {
	PreviousHash   common.Hash    `json:"previoushash"` // the hash of the previous block header on current chain
	HashHistory    common.Hash    `json:"history"`      // hash of the history tree of hash for each block recorded in height order
	ChainID        common.ChainID `json:"chainid"`      // current chain id
	Height         common.Height  `json:"height"`       // height of current block
	Empty          bool           `json:"empty"`        // empty block
	ParentHeight   common.Height  `json:"-"`            // height of parent height, is 0 if current is main chain
	ParentHash     *common.Hash   `json:"-"`            // block hash of main chain block at ParentHeight, nil if current is main chain
	RewardAddress  common.Address `json:"-"`            // reward to
	AttendanceHash *common.Hash   `json:"-"`            // The current epoch attendance record hash
	RewardedCursor *common.Height `json:"-"`            // If the current chain is the reward chain, record start height of main chain when next reward issues

	CommitteeHash    *common.Hash   `json:"-"`    // current epoch Committee member trie root hash
	ElectedNextRoot  *common.Hash   `json:"-"`    // root hash of the election result of next epoch committee members
	NewCommitteeSeed *common.Seed   `json:"seed"` // Current election seeds, only in the main chain
	RREra            *common.EraNum `json:"-"`    // the era corresponding to the root of the current Required Reserve tree. When this value is inconsistent with the height of main chain, it indicates that a new RR tree needs to be calculated
	RRRoot           *common.Hash   `json:"-"`    // root hash of the Required Reserve tree in current era. Only in the reward chain and the main chain
	RRNextRoot       *common.Hash   `json:"-"`    // root hash of the Required Reserve tree in next era. Only in the reward chain and the main chain
	RRChangingRoot   *common.Hash   `json:"-"`    // changes waiting to be processed in current era

	MergedDeltaRoot  *common.Hash `json:"mergeroot"` // Root hash of the merged delta sent from other shards
	BalanceDeltaRoot *common.Hash `json:"deltaroot"` // Root hash of the generated deltas by this block which needs to be sent to the other shards
	StateRoot        common.Hash  `json:"stateroot"` // account on current chain state trie root hash
	ChainInfoRoot    *common.Hash `json:"-"`         // for main chain only: all chain info trie root hash
	WaterlinesRoot   *common.Hash `json:"-"`         // since v2.3.0, the waterlines of other shards to current chain after the execution of this block. nil represent all zeros. Because the value of the previous block needs to be inherited when the block is empty, values after block execution recorded.
	VCCRoot          *common.Hash `json:"-"`         // Root hash of transfer out check tree in business chain
	CashedRoot       *common.Hash `json:"-"`         // Root hash of transfer in check tree in business chain
	TransactionRoot  *common.Hash `json:"-"`         // transactions in current block trie root hash
	ReceiptRoot      *common.Hash `json:"-"`         // receipts for transactions in current block trie root hash
	HdsRoot          *common.Hash `json:"-"`         // if there's any child chain of current chain, this is the Merkle trie root hash generated by the reported block header information of the child chain in order

	TimeStamp uint64 `json:"timestamp"`

	ElectResultRoot *common.Hash `json:"-"` // Since v1.5.0, Election result hash root (including pre election and ordinary election, ordinary one has not been provided yet)
	PreElectRoot    *common.Hash `json:"-"` // Since v1.5.0, the root hash of current preelecting list sorted by (Expire, ChainID), only in the main chain
	FactorRoot      *common.Hash `json:"-"` // since v2.0.0, seed random factor hash
}

type BlockHeight struct {
	ChainID common.ChainID
	Height  common.Height
}

type BlockHeighter interface {
	GetHeight() common.Height
	Hash() common.Hash
}

type BlockReport struct {
	ToChainId   common.ChainID
	BlockHeader *BlockHeader    // the header of the reporting block
	NextComm    *EpochCommittee // next committee when election finished
	BlockPass   []*PubAndSig    // signatures of committee members who comfirmed reporting block. can be changed to aggregate signature in the future
}

type BlockRequest struct {
	ChainId common.ChainID
	Height  common.Height
	NodeId  common.NodeID
}

type BlockSummary struct {
	ChainId   common.ChainID
	Height    common.Height
	BlockHash common.Hash
	// since v1.5.0, the election result of the next committee whill be packaged together.
	// Because only the data and comm node will receive the report and record the next committee
	// of the sub chain. Since the new elected node has already been synchronizing the main chain,
	// it will not synchronize the data again, then it will not be able to synchronize all the sub
	// chain committee information, resulting in the nodes missing the corresponding information
	// when the new epoch begins.
	NextComm *EpochCommittee
	// V0's BlockSummary.Hash is same with blockhash, which can't reflect the location information
	// of the block, and can't complete the proof of cross chain. V1 adds chainid and height to hash
	Version uint16
}

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

type CancelCashCheckRequest struct {
	Check             *CashCheck      `json:"check"`           // cheque to be voided
	AbsenceChainID    common.ChainID  `json:"chain"`           // the target chain of the proof
	AbsenceHeight     common.Height   `json:"height"`          // block height of target chain which proof prove to
	AbsenceHeaderHash common.Hash     `json:"header"`          // the proof target hash of Proofs
	CCCProofs         trie.ProofChain `json:"absence"`         // CashedTrie's proof of non-existence of check
	Proofs            trie.ProofChain `json:"proofs"`          // from CashedTrie.Root Proof chain to the target of proof
	ConfirmedHeight   common.Height   `json:"confirmedHeight"` // the main chain block height which confirmed target block header
}

type CashCheck struct {
	ParentChain  common.ChainID `json:"ParentChain"`  // parent of source chain
	IsShard      bool           `json:"IsShard"`      // whether the source chain is a sharding chain
	FromChain    common.ChainID `json:"FromChain"`    // id of source chain
	FromAddress  common.Address `json:"FromAddr"`     // address of source account
	Nonce        uint64         `json:"Nonce"`        // nonce of the tx to write the CashCheck
	ToChain      common.ChainID `json:"ToChain"`      // target chain id
	ToAddress    common.Address `json:"ToAddr"`       // address of the target account
	ExpireHeight common.Height  `json:"ExpireHeight"` // The expired height refers to that when the height of the target chain exceeds (excluding) this value, the check cannot be withdrawn and can only be returned
	UserLocal    bool           `json:"UseLocal"`     // true: local currency, false: basic currency, default is false
	Amount       *big.Int       `json:"Amount"`       // amount of the check
	CurrencyID   common.CoinID  `json:"CoinID"`       // Currency ID, new field, 0 when uselocal==false, currency ID when =true, and 0 for old version data
}

type CashRequest struct {
	Check           *CashCheck      `json:"check"`  // check information to be cashed
	ProofedChainID  common.ChainID  `json:"chain"`  // the target chain of the proof (main chain)
	ProofHeight     common.Height   `json:"height"` // proof from check hash to block.hash of source chain, and then to main chain block.hash. this is the corresponding main chain block height
	ProofHeaderHash common.Hash     `json:"header"` // block hash which height is specified by ProofHeight
	Proofs          trie.ProofChain `json:"proofs"` // proof of check
}

type ChainContext interface {

	// GetHeader returns the hash corresponding to their hash.
	GetHeader(common.Hash, uint64) *BlockHeader
}

type ChainCurrencier interface {
	GlobalCurrencier
	// Whether there is a local currency, if so, the last one method will return the local currency
	// information. Otherwise, the latter one method return basic currency information
	HasLocalCurrency() bool
	// Return (local currency ID, local currency name), when the local currency ID==0, it is the
	// basic currency
	GetLocalCurrency() (common.CoinID, string)
	// Get the list of administrator public keys of the current chain. If there is a valid value,
	// the second return value will return true, otherwise it will return false
	GetAdmins() ([][]byte, bool)
	// Whether the current chain is a PoC (Proof of Capacity) chain
	IsPoc() bool
}

type ChainCurrencierAdapter struct {
	GlobalCurrencier
	CID common.ChainID
}

type ChainElectResult struct {
	ChainID common.ChainID  // Election chain
	Epoch   common.EpochNum // The Epoch where the election took place, the value of the pre-election is NilEpoch
	Results NodeResults
}

type ChainElectResults []*ChainElectResult

type ChainEpochCommittee struct {
	ChainID common.ChainID
	Epoch   common.EpochNum
	Comm    *EpochCommittee
}

type ChainEvent interface {
	GetChainID() common.ChainID
}

type ChainInfoChange struct {
	Sender common.Address // TX.From
	Nonce  uint64         // TX.Nonce, Sender + Nonce combination should prevent replay attacks
	Data   []byte         // information to be modified
}

type ChainSetting struct {
	Sender common.Address // Address of sender, should same with TX.From
	Nonce  uint64         // TX.Nonce, Sender+Nonce combination should prevent replay attacks
	Name   string         // setting name to be set
	Data   []byte         // setting value to be set
}

type ChainSnapshot struct {
	Height     common.Height    // current height
	Block      *BlockEMessage   // block of current height
	Waterlines []ShardWaterline // waterlines of shards at current height
	CheckEpoch bool             // whether to check epoch matchness
}

type ChainStats struct {
	CurrentHeight      uint64          `json:"currentheight"`      // current height of the chain
	SumTxCount         uint64          `json:"txcount"`            // The number of current chain transactions after this launch
	AllTps             uint64          `json:"tps"`                // Current chain TPS after this launch
	LastEpochTps       uint64          `json:"tpsLastEpoch"`       // TPS of the previous epoch after this launch
	LastNTps           uint64          `json:"tpsLastN"`           // TPS of previous %N blocks
	Lives              uint64          `json:"lives"`              // Running time after this launch (in seconds)
	AccountCount       uint64          `json:"accountcount"`       // 0
	EpochLength        uint64          `json:"epochlength"`        // The number of blocks in one epoch
	AvgEpochDuration   uint64          `json:"epochduration"`      // Average time of an epoch (in seconds)
	LastEpochDuration  uint64          `json:"lastepochduration"`  // The time spent in the last epoch (in seconds)
	LastNDuration      uint64          `json:"lastNduration"`      // Time spent in the previous %N blocks (in seconds)
	LastEpochBlockTime uint64          `json:"lastEpochBlockTime"` // The average block time of the last epcoh (in milliseconds)
	LastNBlockTime     uint64          `json:"lastNBlockTime"`     // Average block time of previous %N blocks (in milliseconds)
	N                  uint64          `json:"N"`                  // The value of N
	GasLimit           uint64          `json:"gaslimit"`           // Current chain default GasLimit
	GasPrice           string          `json:"gasprice"`           // Current chain default GasPrice
	CurrentComm        []common.NodeID `json:"currentcomm"`        // The node list of the current committee of the chain
	Version            string          `json:"version"`            // Version of current node
}

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

type ChangeChainInfoRequest struct {
	Data *ChainInfoChange
	Sigs [][]byte // signature list
	Pubs [][]byte // public key list corresponding to signature one by one
}

type CodeEntry struct {
	K common.Hash
	V []byte
}

type CommEntry struct {
	ChainID common.ChainID
	Comm    *Committee
}

type CommReport struct {
	ChainId   common.ChainID
	ToChainId common.ChainID
	EpochNum  common.EpochNum
	Comm      *Committee
}

type CommitCallback func(block *BlockEMessage) error

type Committee struct {
	Members []common.NodeID
	// contains filtered or unexported fields
}

type CompatibleAccount struct {
	Addr        common.Address
	Nonce       uint64
	Balance     *big.Int
	StorageRoot []byte
	CodeHash    []byte
}

type CompatibleDelta struct {
	Addr  common.Address
	Delta *big.Int
}

type ConnectedCallBackFunc func(id common.ChainID, netType common.NetType, server P2PServer)

type Context struct {
	Op        *OpSet
	Eventer   Eventer
	ChainInfo *common.ChainInfos
	ShardInfo common.ShardInfo
	Networker Networker
	Holder    DataHolder
	Engine    Engine

	// source of message
	Source Location

	// for test adapter
	// cengine   consensus.Engine
	// mainChain *consensus.MainChain
	Dmanager DataManager
	Nmanager NetworkManager

	WorkerName string
	Logger     logrus.FieldLogger
	PAS        *PubAndSig
}

type DataHolder interface {
	// GetChainInfo() *common.ChainInfos
	// GetShardInfo returns ShardInfo only if current chain is a shard chain
	GetShardInfo() common.ShardInfo
	GetChainInfoRoot() (*common.Hash, error)
	SetGenesisHeader(header *BlockHeader) error
	GetChainInfo() (*common.ChainInfos, bool)
	// ChainList() common.ChainIDs
	GetDataNodeList() common.NodeIDs
	IsDataNode() bool // is it the data node of current chain
	IsMemoNode() bool // is it the full node of current chain
	IncCount(height common.Height, timestamp uint64, count uint64)
	// FIXME: should not reture database to other layer
	GetDb() db.Database

	// GetBlockChain get BlockChain of current Chain
	GetBlockChain() BlockChain
	GetBlock(height common.Height) (*BlockEMessage, error)
	GetBlockByHash(hashOfHeader []byte) (*BlockEMessage, error)
	GetBlockWithUnverified(height common.Height) (*BlockEMessage, error)
	SaveUnverifiedBlock(block *BlockEMessage) error
	GetBlockHash(height common.Height) (*common.Hash, bool)
	GetHeader(height common.Height) (*BlockHeader, error)
	GetHistoryRoot(expectingHeight common.Height) ([]byte, error)
	// SaveRewardRequests(block *BlockEMessage, hashOfBlock []byte) error
	PutBlock(block *BlockEMessage, appendSuccessFunc BlockAppendSuccess) error

	CreateEmptyAccountTrie() *trie.Trie
	CreateAccountTrie(rootHash []byte) *trie.Trie
	RestoreHistoryTreeFromProofs(lastHeight common.Height, lastHeightHash []byte,
		proofs trie.ProofChain) (*trie.HistoryTree, error)
	CreateHistoryTree(root []byte, checkPrecedingNil bool) (*trie.HistoryTree, error)
	CreateEmptyVccOrigin() *trie.Trie
	CreateEmptyCashedOrigin() *trie.Trie
	SyncState(height common.Height, block *BlockEMessage, states *WholeWorld, logger logrus.FieldLogger) error
	SyncChains(chains *trie.Trie) error
	SyncAccTrie(height common.Height, accStates *trie.Trie) error
	SyncBlock(block *BlockEMessage) error
	// IsSynced returns 0 if the chain is not yet synced, and returns 1 if synced
	IsSynced() bool
	SetSynced()
	IsFull() bool
	StopSyncing()
	IsEmpty() bool
	IsExpectingEpoch(epoch common.EpochNum) error
	GetCurrentHeight() common.Height
	SetCurrentHeight(height common.Height)
	SetCurrentToHeight(height common.Height, hob common.Hash) error

	GetWorldStateRoot() ([]byte, error)
	SnapshotRoots() (snapshot *ChainSnapshot, err error)
	GetWorldStateStream(snapshot *ChainSnapshot) (accStream [][]byte,
		stoStream [][]byte, codeStream [][]byte, longStream [][]byte, deltaStream [][]byte, chainsStream []byte, err error)
	GetCashCheckState(vccRoot, cashedRoot []byte) (vccs, casheds [][]byte, err error)

	// GetTransactions returns transaction trie in specific block
	GetTransactions(height common.Height) (trie.ITrie, error)
	// GetReceipts returns receipt list in specific block by its receiptsHash
	GetReceiptsByRoot(receiptHash common.Hash) Receipts

	CallProcessTx(tx *Transaction, senderSig *PubAndSig, blockHeader *BlockHeader) (interface{}, error)

	ProposeData(froms DeltaFroms, header *BlockHeader, txs []*Transaction, pas []*PubAndSig) (result *ProposeResult, err error)

	CanBeAccept(reportChainID common.ChainID, height common.Height, hob []byte) error
	PrepareBlock(block *BlockEMessage) error
	ForceCommit() (err error)

	CreateRootDeltaTrie() *AccountDeltaTrie
	// RestoreDeltaTrieFromBlock recover complete AccountDeltaTrie from block。
	RestoreDeltaTrieFromBlock(block *BlockEMessage) (*AccountDeltaTrie, error)

	SaveReceivedDelta(fromID common.ChainID, height common.Height, deltas []*AccountDelta) (
		overflow bool, waterline common.Height, overflowed []*DeltaFrom, missing bool, missingLength int, err error)
	SaveDeltasGroup(fromID common.ChainID, group DeltasGroup) (overflow bool,
		waterline common.Height, overflowed []*DeltaFrom, missing bool, missingLength int, err error)

	CheckReceivedDelta(fromID common.ChainID, height common.Height) bool

	CreateAccountDeltaTrie() trie.ITrie
	PopDeltaFroms() DeltaFroms
	PutDeltaFroms(deltaFroms DeltaFroms)
	CreateDeltaFromTrie() *AccountDeltaFromTrie
	ShouldSendDelta() (A, B common.Height, confirmed common.Height, mainBlockSummary *HeaderSummary, err error)
	SetDeltaToBeSent(height common.Height)
	VerifyDeltasPack(pack *DeltasPack) error

	// Verifiable Cash Check Trie
	AddVCC(vcc *CashCheck) (hashOfVcc []byte, err error)
	DeleteVCC(vcc *CashCheck) (ok bool, hashOfVcc []byte, err error)
	VccProof(vcc *CashCheck) (height common.Height, proofChain trie.ProofChain, hashOfHeader []byte, err error)
	AddCCC(vcc *CashCheck, txHash *common.Hash) (hashOfVcc []byte, err error)
	CCCExsitenceProof(ccc *CashCheck) (height common.Height, existence bool, existProof trie.ProofChain,
		cashedRootProof trie.ProofChain, hashOfHeader []byte, err error)
	GetCCCRelativeTx(hashOfVcc []byte) (hashOfTx []byte, err error)

	CreateVCCTrie(root []byte) *trie.Trie
	CreateCCCTrie(root []byte) *trie.Trie

	GetAccount(addr *common.Address) (*Account, bool)
	GetCodeByHash(codeHash common.Hash) []byte
	GetGasSettings() (gasPrice *big.Int, gasLimit uint64)

	SwitchEpoch()
	HasChild() bool

	// Record the committee election result comm of chainid chain in epoch num. if comm is
	// not available, prev is the last effective committee.
	// Because the parent chain needs to keep the consensus committee information of the
	// sub chain, chainId is necessary.
	PutCommittee(chainId common.ChainID, num common.EpochNum, comm *Committee, prev *Committee) error
	GetCommittee(chainId common.ChainID, num common.EpochNum) (*Committee, error)
	GetEpochComm(chainId common.ChainID, num common.EpochNum) (*EpochCommittee, error)
	SyncCommittees(currentHeight common.Height) ([]*ChainEpochCommittee, error)

	PutHeaderSummaries(bock *BlockEMessage) error
	GetHeaderSummary(chainId common.ChainID, height common.Height) (*HeaderSummary, error)

	// Interfaces used to record whether messages have been processed
	Process(hash common.Hash) bool
	Processed(hash common.Hash) bool
	RemoveProcessed(hash common.Hash)
	ClearProcessed()

	AppendHistory(height common.Height, hash []byte) (newRoot []byte, err error)
	SetSyncFinish(height common.Height)
	GetSyncFinish() common.Height
	SetCursorManually(to common.Height) error
	GetStateDB() StateDB

	GetConsistantLong(addr common.Address, key common.Hash) []byte
	SetLongState(addr common.Address, key common.Hash, value []byte)

	// interfaces for chain management
	MCHAddBootNode(id common.ChainID, bootNode common.Dataserver) (errr error)
	MCHRemoveBootNode(id common.ChainID, nodeId common.NodeID) error
	MCHAddDataNode(id common.ChainID, nodeId common.NodeID) error
	MCHRemoveDataNode(id common.ChainID, nodeId common.NodeID) error
	MCHAddAdmin(id common.ChainID, adminPub []byte) error
	MCHDelAdmin(id common.ChainID, adminPub []byte) error
	MCHAttributes(id common.ChainID, isSet bool, attrs ...common.ChainAttr) error

	// interfaces for election
	GetPreElecting(id common.ChainID) *PreElecting
	PutPreElectResult(resulter ElectResulter)
	ProposePreElecting(height common.Height) (PreElectings, ChainElectResults)
	SetPreelectExamineResult(chainId common.ChainID, success bool) error
	SyncPreElection(electings PreElectings)
	MergeProof(key uint64, value []byte, proofs trie.ProofChain) error

	// interface for check nodes
	CacheAliveDataNode(id common.NodeID, height common.Height)
	LoadAliveDataNodes() common.NodeIDs
	ClearAliveDataNodes(height common.Height)
}

type DataManager interface {
	common.Service
	Eventer() Eventer
	SetChainStructs(chains *config.Config)
	InitOneChain(chainid common.ChainID) error
	CreateGenesisData(chainId common.ChainID) error
	CreateChainInfosOrigin(rootHash []byte) *trie.Trie
	GetChainInfos(id common.ChainID) (*common.ChainInfos, bool)
	IsInUsingDataNode(dataNodeId common.NodeID) (common.ChainID, bool)
	IsNoGasChain(chainId common.ChainID) (bool, common.ChainID)
	GetChainStats(id common.ChainID) (*ChainStats, error)
	DataNodeOf() common.ChainID
	IsDataNode() bool
	IsMemoNode() bool
	// Deprecated
	IsDataMemoNode() bool
	GetShardInfo(chainid common.ChainID) common.ShardInfo
	IsDataNodeOf(id common.ChainID) bool
	IsShard(id common.ChainID) bool
	HasAttribute(id common.ChainID, attr common.ChainAttr) bool
	IsLeaf(id common.ChainID) bool
	GetChainChildren(chainid common.ChainID) common.ChainIDs
	GetChainChildrenAndSelfInfos(chainid common.ChainID) []*common.ChainInfos
	GetDataNodes(id common.ChainID) map[common.NodeID]struct{}
	GetGenesisDataNodeList(id common.ChainID) common.NodeIDs
	GetDataNodeList(id common.ChainID) common.NodeIDs
	GetDataNodeIDs(chainId common.ChainID) common.NodeIDs // Return if there is a list of Genesis data nodes, otherwise return to the list of data nodes
	GetChainList() common.ChainIDs
	GetVrfChainList() common.ChainIDs
	GetAllChainInfos() []*common.ChainInfos
	GetGenesisNodes() map[common.NodeID]common.NodeType
	CreateTestAccount(chainid common.ChainID, addr common.Address, balance *big.Int, local *big.Int) error
	ForceCommit(chainid common.ChainID) error
	// GetAccount(addr *common.Address, chainID common.ChainID) (Account, bool)
	GetChainData(chainid common.ChainID) (DataHolder, error)
	GetMainChainLong(addr common.Address, key common.Hash) []byte
	GetChainLong(chainid common.ChainID, addr common.Address, key common.Hash) []byte
	RemoveChain(chainid common.ChainID)
	GetHeaderSummaries(chainid common.ChainID, height common.Height) ([]*HeaderSummary, error)

	SetCursorManually(to common.Height) error

	ReadOnly() DataManager
	GetStartNodes() common.NodeIDs
	AddStartNode(id common.NodeID)
	StartNodesSize() int
	AddLastComm(lastComm *LastCommEMessage) error
	ToStartComm(chainIds common.ChainIDs) (*StartCommEMessage, error)
	// cache seed
	SetSeed(epoch common.EpochNum, newseed *common.Seed) bool
	GetSeed() *common.Seed
	LastSeedUpdatedAt() common.EpochNum
	SaveCommitteeAt(at common.ChainID, commChain common.ChainID,
		epoch common.EpochNum, comm, prev *Committee) error
	GetCommitteeAt(at common.ChainID, commChain common.ChainID, epoch common.EpochNum) (*EpochCommittee, error)
}

type DataRequester interface {
	DataSerialize(w io.Writer) error
	DataDeserialize(vr rtl.ValueReader) error
	GetData() (o interface{}, exist bool)
	GetSigs() [][]byte
	SetSigs(sigs [][]byte)
	GetPubs() [][]byte
	SetPubs(pubs [][]byte)
}

type DeltaFrom struct {
	Key    DeltaFromKey
	Deltas []*AccountDelta
}

type DeltaFromKey struct {
	ShardID common.ChainID
	Height  common.Height
}

type DeltaFroms []DeltaFrom

type DeltaRequestMessage struct {
	FromID common.ChainID // source chain of requested delta
	ToID   common.ChainID // target chain of requested delta
	Start  common.Height  // The starting height of the source chain where the requested delta is located
	Length int            // The number of delta requested, starting from start (including start)
}

type DeltasGroup []*OneDeltas

type DeltasPack struct {
	FromID        common.ChainID  // source chain id
	ToChainID     common.ChainID  // target shard id
	ProofedHeight common.Height   // block B of source shard was confirmed by the main chain
	ProofToMain   trie.ProofChain // proof from B.Hash to C.Hash
	MainHeight    common.Height   // the height of main chain block C which packed and confirmed block B
	Pack          DeltasGroup     // deltas of each block from source chain
}

type DirectiveMsg interface {
	DestChainID() common.ChainID
}

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

type DynamicFeeTx struct {
	ChainID    *big.Int
	Nonce      uint64
	GasTipCap  *big.Int
	GasFeeCap  *big.Int
	Gas        uint64
	To         *common.Address `rlp:"nil"` // nil means contract creation
	Value      *big.Int
	Data       []byte
	AccessList AccessList

	// Signature values
	V *big.Int `json:"v" gencodec:"required"`
	R *big.Int `json:"r" gencodec:"required"`
	S *big.Int `json:"s" gencodec:"required"`
}

type EIP155Signer struct {
}

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

type ElectCallback func(keepComm bool, oldcomm *Committee, newcomm *Committee)

type ElectMessage struct {
	// EpochNum is the current epoch number
	// I.e., the elected committee is for epoch EpochNum+1
	EpochNum     common.EpochNum `json:"epoch"` // 选举时所在epoch
	ElectChainID common.ChainID  `json:"chainid"`
}