chain_state

type Chain interface {
	IterateAccounts(iterateFunc func(addr types.Address, accountId uint64, err error) bool)

	QueryLatestSnapshotBlock() (*ledger.SnapshotBlock, error)

	GetLatestSnapshotBlock() *ledger.SnapshotBlock

	GetSnapshotHeightByHash(hash types.Hash) (uint64, error)

	GetUnconfirmedBlocks(addr types.Address) []*ledger.AccountBlock

	GetAccountBlockByHash(blockHash types.Hash) (*ledger.AccountBlock, error)

	GetSnapshotHeaderBeforeTime(timestamp *time.Time) (*ledger.SnapshotBlock, error)

	GetSnapshotHeadersAfterOrEqualTime(endHashHeight *ledger.HashHeight, startTime *time.Time, producer *types.Address) ([]*ledger.SnapshotBlock, error)

	// header without snapshot content
	GetSnapshotHeaderByHeight(height uint64) (*ledger.SnapshotBlock, error)

	StopWrite()

	RecoverWrite()
}

type Consensus interface {
	VerifyAccountProducer(block *ledger.AccountBlock) (bool, error)
	SBPReader() core.SBPStatReader
}

type EventListener interface {
	PrepareInsertAccountBlocks(blocks []*vm_db.VmAccountBlock) error
	InsertAccountBlocks(blocks []*vm_db.VmAccountBlock) error

	PrepareInsertSnapshotBlocks(snapshotBlocks []*ledger.SnapshotBlock) error
	InsertSnapshotBlocks(snapshotBlocks []*ledger.SnapshotBlock) error

	PrepareDeleteAccountBlocks(blocks []*ledger.AccountBlock) error
	DeleteAccountBlocks(blocks []*ledger.AccountBlock) error

	PrepareDeleteSnapshotBlocks(chunks []*ledger.SnapshotChunk) error
	DeleteSnapshotBlocks(chunks []*ledger.SnapshotChunk) error
}

type FlushingBatch struct {
	Operation byte
	Batch     *leveldb.Batch
}

type LogItem struct {
	Storage      [][2][]byte
	BalanceMap   map[types.TokenTypeId]*big.Int
	Code         []byte
	ContractMeta map[types.Address][]byte
	VmLogList    map[types.Hash][]byte
	CallDepth    map[types.Hash]uint16
	Height       uint64 // account block height
}

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

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

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

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

type RedoInterface interface {
	Close() error
	InsertSnapshotBlock(snapshotBlock *ledger.SnapshotBlock, confirmedBlocks []*ledger.AccountBlock)
	HasRedo(snapshotHeight uint64) (bool, error)
	QueryLog(snapshotHeight uint64) (SnapshotLog, bool, error)
	SetCurrentSnapshot(snapshotHeight uint64, logMap SnapshotLog)
	AddLog(addr types.Address, log LogItem)
	Rollback(chunks []*ledger.SnapshotChunk)
	// contains filtered or unexported methods
}

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

type RoundCacheInterface interface {
	Init(timeIndex core.TimeIndex) (returnErr error)
	InsertSnapshotBlock(snapshotBlock *ledger.SnapshotBlock, snapshotLog SnapshotLog) (returnErr error)
	DeleteSnapshotBlocks(snapshotBlocks []*ledger.SnapshotBlock) error
	GetSnapshotViteBalanceList(snapshotHash types.Hash, addrList []types.Address) (map[types.Address]*big.Int, []types.Address, error)
	StorageIterator(snapshotHash types.Hash) interfaces.StorageIterator
	// contains filtered or unexported methods
}

type RoundCacheLogItem struct {
	Storage    [][2][]byte
	BalanceMap map[types.TokenTypeId]*big.Int
}

type RoundCacheRedoLogs struct {
	Logs []*RoundCacheSnapshotLog
}

type RoundCacheSnapshotLog struct {
	LogMap map[types.Address][]RoundCacheLogItem

	SnapshotHeight uint64
}

type SnapshotLog map[types.Address][]LogItem

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

type StateDBInterface interface {
	NewStorageIterator(addr types.Address, prefix []byte) interfaces.StorageIterator
	NewSnapshotStorageIteratorByHeight(snapshotHeight uint64, addr types.Address, prefix []byte) (interfaces.StorageIterator, error)
	NewSnapshotStorageIterator(snapshotHash types.Hash, addr types.Address, prefix []byte) (interfaces.StorageIterator, error)
	NewRawSnapshotStorageIteratorByHeight(snapshotHeight uint64, addr types.Address, prefix []byte) interfaces.StorageIterator
	RollbackSnapshotBlocks(deletedSnapshotSegments []*ledger.SnapshotChunk, newUnconfirmedBlocks []*ledger.AccountBlock) error
	RollbackAccountBlocks(accountBlocks []*ledger.AccountBlock) error

	Init() error
	Close() error
	SetConsensus(cs Consensus) error
	GetStorageValue(addr *types.Address, key []byte) ([]byte, error)
	GetBalance(addr types.Address, tokenTypeId types.TokenTypeId) (*big.Int, error)
	GetBalanceMap(addr types.Address) (map[types.TokenTypeId]*big.Int, error)
	GetCode(addr types.Address) ([]byte, error)
	GetContractMeta(addr types.Address) (*ledger.ContractMeta, error)
	IterateContracts(iterateFunc func(addr types.Address, meta *ledger.ContractMeta, err error) bool)
	HasContractMeta(addr types.Address) (bool, error)
	GetContractList(gid *types.Gid) ([]types.Address, error)
	GetVmLogList(logHash *types.Hash) (ledger.VmLogList, error)
	GetCallDepth(sendBlockHash *types.Hash) (uint16, error)
	GetSnapshotBalanceList(balanceMap map[types.Address]*big.Int, snapshotBlockHash types.Hash, addrList []types.Address, tokenId types.TokenTypeId) error
	GetSnapshotValue(snapshotBlockHeight uint64, addr types.Address, key []byte) ([]byte, error)
	SetCacheLevelForConsensus(level uint32)
	Store() *chain_db.Store
	RedoStore() *chain_db.Store
	Redo() RedoInterface
	GetStatus() []interfaces.DBStatus

	NewStorageDatabase(snapshotHash types.Hash, addr types.Address) (StorageDatabaseInterface, error)

	Write(block *vm_db.VmAccountBlock) error
	WriteByRedo(blockHash types.Hash, addr types.Address, redoLog LogItem)
	InsertSnapshotBlock(snapshotBlock *ledger.SnapshotBlock, confirmedBlocks []*ledger.AccountBlock) error
	// contains filtered or unexported methods
}

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

type StorageDatabaseInterface interface {
	GetValue(key []byte) ([]byte, error)
	NewStorageIterator(prefix []byte) (interfaces.StorageIterator, error)
	Address() *types.Address
}

type TimeIndex interface {
	Index2Time(index uint64) (time.Time, time.Time)
	Time2Index(t time.Time) uint64
}

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