epochStart

Documentation

Index

• Variables
• type ActionHandler
• type AuctionListSelector
• type EpochEconomicsDataProvider
• type EpochNotifier
• type EpochStartNotifier
• type HeaderValidator
• type HeadersByHashSyncer
• type ImportStartHandler
• type ManualEpochStartNotifier
• type MaxNodesChangeConfigProvider
• type NodesConfigProvider
• type Notifier
• type OwnerData
• type PendingMiniBlocksSyncHandler
• type RegistrationHandler
• type RequestHandler
• type RewardsCreator
• type RoundHandler
• type StakingDataProvider
• type StartOfEpochMetaSyncer
• type TransactionCacher
• type TriggerHandler
• type ValidatorInfoCacher
• type ValidatorInfoCreator
• type ValidatorStatsInEpoch

Variables

var ErrCouldNotInitDelegationSystemSC = errors.New("could not init delegation system sc")

ErrCouldNotInitDelegationSystemSC signals that delegation system sc init failed

var ErrEmptyESDTOwnerAddress = errors.New("empty ESDT owner address")

ErrEmptyESDTOwnerAddress signals that an empty ESDT owner address was provided

var ErrEndOfEpochEconomicsDataDoesNotMatch = errors.New("end of epoch economics data does not match")

ErrEndOfEpochEconomicsDataDoesNotMatch signals that end of epoch data does not match

var ErrEpochStartDataForShardNotFound = errors.New("epoch start data for current shard not found")

ErrEpochStartDataForShardNotFound signals that epoch start shard data was not found for current shard id

var ErrExecutingSystemScCode = errors.New("error executing system SC code")

ErrExecutingSystemScCode signals that an error occurred while executing system SC code

var ErrInvalidAccumulatedFees = errors.New("accumulated rewards are invalid")

ErrInvalidAccumulatedFees signals that the accumulated fees are invalid

var ErrInvalidAmountMintedTokens = errors.New("amount of minted tokens is invalid")

ErrInvalidAmountMintedTokens signals that the amount of minted tokens is invalid

var ErrInvalidConsensusThreshold = errors.New("invalid consensus threshold")

ErrInvalidConsensusThreshold signals that an invalid consensus threshold has been provided

var ErrInvalidEstimatedProtocolSustainabilityRewards = errors.New("estimated protocol sustainability rewards are invalid")

ErrInvalidEstimatedProtocolSustainabilityRewards signals that the estimated protocol sustainability rewards are invalid

var ErrInvalidInflationRate = errors.New("inflation rate is invalid")

ErrInvalidInflationRate signals usage of an invalid inflation rate

var ErrInvalidMaxHardCapForMissingNodes = errors.New("invalid max hardcap for missing nodes")

ErrInvalidMaxHardCapForMissingNodes signals that the maximum hardcap value for missing nodes is invalid

var ErrInvalidMaxNumberOfNodes = errors.New("maximum number of nodes invalid")

ErrInvalidMaxNumberOfNodes signals that the maximum number of nodes is invalid

var ErrInvalidMinNodePrice = errors.New("minimum node price is invalid")

ErrInvalidMinNodePrice signals that the minimum node price is invalid (e.g. negative, not a number, etc)

var ErrInvalidMinNumberOfNodes = errors.New("minimum number of nodes invalid")

ErrInvalidMinNumberOfNodes signals that the minimum number of nodes is invalid

var ErrInvalidNumConcurrentTrieSyncers = errors.New("invalid num concurrent trie syncers")

ErrInvalidNumConcurrentTrieSyncers signals that the number of concurrent trie syncers is invalid

var ErrInvalidRewardsPerBlock = errors.New("invalid rewards per block")

ErrInvalidRewardsPerBlock signals that the computed rewards per block are invalid

var ErrInvalidSettingsForEpochStartTrigger = errors.New("invalid start of epoch trigger settings")

ErrInvalidSettingsForEpochStartTrigger signals that settings for start of epoch trigger are invalid

var ErrInvalidSystemSCReturn = errors.New("invalid system sc return")

ErrInvalidSystemSCReturn signals that system sc returned with something unexpected

var ErrInvalidTotalToDistribute = errors.New("invalid total to distribute")

ErrInvalidTotalToDistribute signals that the computed total rewards to be distributed is invalid

var ErrMetaHdrNotFound = errors.New("meta header not found")

ErrMetaHdrNotFound signals that metaheader was not found

var ErrMissingHeader = errors.New("missing header")

ErrMissingHeader signals that searched header is missing

var ErrNilAccountsDB = errors.New("nil accounts DB")

ErrNilAccountsDB signals that nil accounts DB has been provided

var ErrNilArgsNewMetaEpochStartTrigger = errors.New("nil arguments for meta start of epoch trigger")

ErrNilArgsNewMetaEpochStartTrigger signals that nil arguments were provided

var ErrNilArgsNewShardEpochStartTrigger = errors.New("nil arguments for shard start of epoch trigger")

ErrNilArgsNewShardEpochStartTrigger signals that nil arguments for shard epoch trigger has been provided

var ErrNilArgumentsParser = errors.New("nil arguments parsers")

ErrNilArgumentsParser signals that nil arguments parser was provided

var ErrNilAuctionListSelector = errors.New("nil auction list selector has been provided")

ErrNilAuctionListSelector signals that a nil auction list selector has been provided

var ErrNilBlockBody = errors.New("nil block body")

ErrNilBlockBody signals that a nil block body has been provided

var ErrNilBlockKeyGen = errors.New("nil block key generator")

ErrNilBlockKeyGen signals that a nil block key generator has been provided

var ErrNilBlockSingleSigner = errors.New("nil block single signer")

ErrNilBlockSingleSigner signals that a nil block single signer has been provided

var ErrNilChanceComputer = errors.New("nil chance computer")

ErrNilChanceComputer signals that nil chance computer has been provided

var ErrNilCoreComponentsHolder = errors.New("nil core components holder")

ErrNilCoreComponentsHolder signals that a nil core components holder was provided

var ErrNilCryptoComponentsHolder = errors.New("nil crypto components holder")

ErrNilCryptoComponentsHolder signals that a nil crypto components holder was provided

var ErrNilCurrentEpochValidatorsInfoPool = errors.New("current epoch validators info pool is nil")

ErrNilCurrentEpochValidatorsInfoPool signals that a nil value for the currentEpochValidatorsInfoPool has been provided

var ErrNilDataPoolsHolder = errors.New("nil data pools holder")

ErrNilDataPoolsHolder signals that nil data pools holder has been provided

var ErrNilDataTrie = errors.New("nil data trie")

ErrNilDataTrie signals that a nil data trie was provided

var ErrNilEconomicsData = errors.New("nil economics data")

ErrNilEconomicsData signals that a nil economics data handler has been provided

var ErrNilEconomicsDataProvider = errors.New("end of epoch economics data provider is nil")

ErrNilEconomicsDataProvider signals that the economics data provider is nil

var ErrNilEnableEpochsHandler = errors.New("nil enable epochs handler")

ErrNilEnableEpochsHandler signals that a nil enable epochs handler has been provided

var ErrNilEndOfEpochCallerAddress = errors.New("nil end of epoch caller address")

ErrNilEndOfEpochCallerAddress signals that nil end of epoch caller address was provided

var ErrNilEpochNotifier = errors.New("nil EpochNotifier")

ErrNilEpochNotifier signals that the provided EpochNotifier is nil

var ErrNilEpochStartNotifier = errors.New("nil epoch start notifier")

ErrNilEpochStartNotifier signals that nil epoch start notifier has been provided

var ErrNilEpochStartSettings = errors.New("nil start of epoch settings")

ErrNilEpochStartSettings signals that nil start of epoch settings has been provided

var ErrNilExecutionOrderHandler = errors.New("nil execution order handler")

ErrNilExecutionOrderHandler signals that a nil execution order handler has been provided

var ErrNilGenesisNodesConfig = errors.New("nil genesis nodes config")

ErrNilGenesisNodesConfig signals that a nil genesis nodes config has been provided

var ErrNilGenesisTotalSupply = errors.New("nil genesis total supply")

ErrNilGenesisTotalSupply signals that nil genesis total supply has been provided

var ErrNilHasher = errors.New("nil hasher")

ErrNilHasher signals that nil hasher has been provided

var ErrNilHeaderHandler = errors.New("nil header handler")

ErrNilHeaderHandler signals that a nil header handler has been provided

var ErrNilHeaderIntegrityVerifier = errors.New("nil header integrity verifier handler")

ErrNilHeaderIntegrityVerifier signals that a nil header integrity verifier was provided

var ErrNilHeaderValidator = errors.New("nil header validator")

ErrNilHeaderValidator signals that nil header validator has been provided

var ErrNilHeadersSyncer = errors.New("nil headers syncer")

ErrNilHeadersSyncer signals that a nil headers syncer has been provided

var ErrNilKeyGen = errors.New("nil key generator")

ErrNilKeyGen signals that a nil key generator has been provided

var ErrNilLatestStorageDataProvider = errors.New("nil latest storage data provider")

ErrNilLatestStorageDataProvider signals that a nil latest storage data provider was provided

var ErrNilLocalTxCache = errors.New("nil local tx cache")

ErrNilLocalTxCache signals that nil local tx cache has been provided

var ErrNilManagedPeersHolder = errors.New("nil managed peers holder")

ErrNilManagedPeersHolder signals that a nil managed peers holder has been provided

var ErrNilMarshalizer = errors.New("nil marshalizer")

ErrNilMarshalizer signals that nil marshalizer has been provided

var ErrNilMaxNodesChangeConfigProvider = errors.New("nil nodes config provider has been provided")

ErrNilMaxNodesChangeConfigProvider signals that a nil nodes config provider has been provided

var ErrNilMessenger = errors.New("nil messenger")

ErrNilMessenger signals that a nil messenger has been provided

var ErrNilMetaBlock = errors.New("nil meta block")

ErrNilMetaBlock signals that a nil meta block has been provided

var ErrNilMetaBlocksPool = errors.New("nil metablocks pool")

ErrNilMetaBlocksPool signals that nil metablock pools holder has been provided

var ErrNilMetablockProcessor = errors.New("nil metablock processor")

ErrNilMetablockProcessor signals that a nil metablock processor was provided

var ErrNilMiniBlockPool = errors.New("nil mini block pool")

ErrNilMiniBlockPool signals that a nil mini blocks pool was used

var ErrNilMiniBlocksSyncer = errors.New("nil miniBlocks syncer")

ErrNilMiniBlocksSyncer signals that a nil miniBlocks syncer has been provided

var ErrNilMiniblock = errors.New("nil miniblock")

ErrNilMiniblock signals that nil miniBlock has been provided

var ErrNilMiniblocks = errors.New("nil arguments for miniblocks object")

ErrNilMiniblocks signals that nil argument was passed

var ErrNilNodesConfigProvider = errors.New("nil nodes config provider")

ErrNilNodesConfigProvider signals that an operation has been attempted to or with a nil nodes config provider

var ErrNilPathManager = errors.New("nil path manager")

ErrNilPathManager signals that a nil path manager has been provided

var ErrNilProtocolSustainabilityAddress = errors.New("nil protocol sustainability address")

ErrNilProtocolSustainabilityAddress signals that a nil protocol sustainability address was provided

var ErrNilPubKey = errors.New("nil public key")

ErrNilPubKey signals that a nil public key has been provided

var ErrNilPubkeyConverter = errors.New("nil pubkey converter")

ErrNilPubkeyConverter signals that nil address converter was provided

var ErrNilRater = errors.New("nil rater")

ErrNilRater signals that a nil rater has been provided

var ErrNilRequestHandler = errors.New("nil request handler")

ErrNilRequestHandler signals that nil request handler has been provided

var ErrNilRewardsHandler = errors.New("rewards handler is nil")

ErrNilRewardsHandler signals that rewards handler is nil

var ErrNilRoundHandler = errors.New("nil RoundHandler")

ErrNilRoundHandler signals that an operation has been attempted to or with a nil RoundHandler implementation

var ErrNilScheduledDataSyncerFactory = errors.New("nil scheduled data syncer factory")

ErrNilScheduledDataSyncerFactory signals that a nil scheduled data syncer factory was provided

var ErrNilScheduledTxsHandler = errors.New("nil scheduled transactions handler")

ErrNilScheduledTxsHandler signals that a nil scheduled transactions handler has been provided

var ErrNilShardCoordinator = errors.New("shard coordinator is nil")

ErrNilShardCoordinator is raised when a valid shard coordinator is expected but nil used

var ErrNilShuffler = errors.New("nil nodes shuffler provided")

ErrNilShuffler signals that a nil shuffler was provided

var ErrNilSingleSigner = errors.New("nil single signer")

ErrNilSingleSigner signals that a nil single signer has been provided

var ErrNilStakingDataProvider = errors.New("nil staking data provider")

ErrNilStakingDataProvider signals that a nil staking data provider was used

var ErrNilStakingSCAddress = errors.New("nil staking system smart contract address")

ErrNilStakingSCAddress signals that nil staking system smart contract address was provided

var ErrNilStatusHandler = errors.New("nil app status handler")

ErrNilStatusHandler signals that a nil status handler has been provided

var ErrNilStorage = errors.New("nil storage")

ErrNilStorage signals that nil storage has been provided

var ErrNilStorageService = errors.New("nil storage service")

ErrNilStorageService signals that a nil storage service has been provided

var ErrNilStorageUnitOpener = errors.New("nil storage unit opener")

ErrNilStorageUnitOpener signals that a nil storage unit opener was provided

var ErrNilSystemVM = errors.New("nil system VM")

ErrNilSystemVM signals that nil system VM has been provided

var ErrNilSystemVmInstance = errors.New("nil system VM instance")

ErrNilSystemVmInstance signals that a nil system VM instance was provided

var ErrNilTotalAccumulatedFeesInEpoch = errors.New("total accumulated fees in epoch is nil")

ErrNilTotalAccumulatedFeesInEpoch signals that total accumulated fees in epoch is nil

var ErrNilTotalDevFeesInEpoch = errors.New("total developer fees in epoch is nil")

ErrNilTotalDevFeesInEpoch signals that total developer fees in epoch is nil

var ErrNilTransactionsSyncer = errors.New("nil transactions syncer")

ErrNilTransactionsSyncer signals that a nil transactions syncer has been provided

var ErrNilTrieSyncStatistics = errors.New("nil trie sync statistics")

ErrNilTrieSyncStatistics signals that nil trie sync statistics has been provided

var ErrNilTxSignMarshalizer = errors.New("nil tx sign marshalizer")

ErrNilTxSignMarshalizer signals that nil tx sign marshalizer has been provided

var ErrNilUint64Converter = errors.New("nil uint64 converter")

ErrNilUint64Converter signals that nil uint64 converter has been provided

var ErrNilValidatorInfo = errors.New("validator info is nil")

ErrNilValidatorInfo signals that a nil value for the validatorInfo has been provided

var ErrNilValidatorInfoProcessor = errors.New("nil validator info processor")

ErrNilValidatorInfoProcessor signals that a nil validator info processor has been provided

var ErrNilValidatorInfoStorage = errors.New("nil validator info storage")

ErrNilValidatorInfoStorage signals that nil validator info storage has been provided

var ErrNilValidatorsInfoPool = errors.New("validators info pool is nil")

ErrNilValidatorsInfoPool signals that a nil value for the validatorsInfoPool has been provided

var ErrNotEnoughNumConnectedPeers = errors.New("not enough min num of connected peers from config")

ErrNotEnoughNumConnectedPeers signals that config is invalid for num of connected peers

var ErrNotEnoughNumOfPeersToConsiderBlockValid = errors.New("not enough num of peers to consider block valid from config")

ErrNotEnoughNumOfPeersToConsiderBlockValid signals that config is invalid for num of peer to consider block valid

var ErrNotEpochStartBlock = errors.New("not epoch start block")

ErrNotEpochStartBlock signals that block is not of type epoch start

var ErrOwnerDoesntHaveEligibleNodesInEpoch = errors.New("owner has no eligible nodes in epoch")

ErrOwnerDoesntHaveEligibleNodesInEpoch signals that the owner doesn't have any eligible nodes in epoch

var ErrOwnerDoesntHaveNodesInEpoch = errors.New("owner has no nodes in epoch")

ErrOwnerDoesntHaveNodesInEpoch signals that the owner has no nodes in epoch

var ErrOwnerHasNoStakedNode = errors.New("owner has no staked node")

ErrOwnerHasNoStakedNode signals that the owner has no staked node

var ErrProtocolSustainabilityAddressInMetachain = errors.New("protocol sustainability address in metachain")

ErrProtocolSustainabilityAddressInMetachain signals that protocol sustainability address is in metachain which is not allowed

var ErrReceivedAuctionValidatorsBeforeStakingV4 = errors.New("auction node has been provided before enabling staking v4")

ErrReceivedAuctionValidatorsBeforeStakingV4 signals that an auction node has been provided before enabling staking v4

var ErrReceivedNewListNodeInStakingV4 = errors.New("new node has been assigned in common.NewList instead of common.AuctionList after staking v4")

ErrReceivedNewListNodeInStakingV4 signals that a new node has been assigned in common.NewList instead of common.AuctionList after staking v4

var ErrResetLastUnJailedFromQueue = errors.New("reset last unjailed from queue failed")

ErrResetLastUnJailedFromQueue signals that reset unjailed from queue failed

var ErrRewardMiniBlockHashDoesNotMatch = errors.New("reward miniblock hash does not match")

ErrRewardMiniBlockHashDoesNotMatch signals that created and received rewards miniblock hash does not match

var ErrRewardMiniBlocksNumDoesNotMatch = errors.New("number of created and received rewards miniblocks missmatch")

ErrRewardMiniBlocksNumDoesNotMatch signals that number of created and received rewards miniblocks is not equal

var ErrStakingSCOutputAccountNotFound = errors.New("staking sc output was not found")

ErrStakingSCOutputAccountNotFound signals that staking sc output account was not found

var ErrSystemDelegationCall = errors.New("delegation system sc call returned with error")

ErrSystemDelegationCall signals that delegation system sc returned with error

var ErrSystemValidatorSCCall = errors.New("system validator sc call failed")

ErrSystemValidatorSCCall signals that system validator sc call failed

var ErrTimeoutWaitingForMetaBlock = errors.New("timeout while waiting for epoch start meta block")

ErrTimeoutWaitingForMetaBlock signals that a timeout event was raised while waiting for the epoch start meta block

var ErrUint32SubtractionOverflow = errors.New("uint32 subtraction overflowed")

ErrUint32SubtractionOverflow signals uint32 subtraction overflowed

var ErrUnStakeExecuteError = errors.New("unstake execution error")

ErrUnStakeExecuteError signals that unstaked returned with error

var ErrValidatorInfoMiniBlocksNumDoesNotMatch = errors.New("number of created and received validatorInfo miniblocks missmatch")

ErrValidatorInfoMiniBlocksNumDoesNotMatch signals that number of created and received validatorInfo miniblocks is not equal

var ErrValidatorMiniBlockHashDoesNotMatch = errors.New("validatorInfo miniblock hash does not match")

ErrValidatorMiniBlockHashDoesNotMatch signals that created and received validatorInfo miniblock hash does not match

var ErrWrongTypeAssertion = errors.New("wrong type assertion")

ErrWrongTypeAssertion signals wrong type assertion

Types

type ActionHandler

type ActionHandler interface {
	EpochStartAction(hdr data.HeaderHandler)
	EpochStartPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)
	NotifyOrder() uint32
}

ActionHandler defines the action taken on epoch start event

type AuctionListSelector

type AuctionListSelector interface {
	SelectNodesFromAuctionList(
		validatorsInfoMap state.ShardValidatorsInfoMapHandler,
		randomness []byte,
	) error
	IsInterfaceNil() bool
}

AuctionListSelector handles selection of nodes from auction list to be sent to waiting list, based on their top up

type EpochEconomicsDataProvider

type EpochEconomicsDataProvider interface {
	SetNumberOfBlocks(nbBlocks uint64)
	SetNumberOfBlocksPerShard(blocksPerShard map[uint32]uint64)
	SetLeadersFees(fees *big.Int)
	SetRewardsToBeDistributed(rewards *big.Int)
	SetRewardsToBeDistributedForBlocks(rewards *big.Int)
	NumberOfBlocks() uint64
	NumberOfBlocksPerShard() map[uint32]uint64
	LeaderFees() *big.Int
	RewardsToBeDistributed() *big.Int
	RewardsToBeDistributedForBlocks() *big.Int
	IsInterfaceNil() bool
}

EpochEconomicsDataProvider provides end of epoch economics data

type EpochNotifier

type EpochNotifier interface {
	RegisterNotifyHandler(handler vmcommon.EpochSubscriberHandler)
	CurrentEpoch() uint32
	CheckEpoch(epoch uint32)
	IsInterfaceNil() bool
}

EpochNotifier can notify upon an epoch change and provide the current epoch

type EpochStartNotifier

type EpochStartNotifier interface {
	RegisterHandler(handler ActionHandler)
	IsInterfaceNil() bool
}

EpochStartNotifier defines which actions should be done for handling new epoch's events

type HeaderValidator

type HeaderValidator interface {
	IsHeaderConstructionValid(currHdr, prevHdr data.HeaderHandler) error
	IsInterfaceNil() bool
}

HeaderValidator defines the actions needed to validate a header

type HeadersByHashSyncer

type HeadersByHashSyncer interface {
	SyncMissingHeadersByHash(shardIDs []uint32, headersHashes [][]byte, ctx context.Context) error
	GetHeaders() (map[string]data.HeaderHandler, error)
	ClearFields()
	IsInterfaceNil() bool
}

HeadersByHashSyncer defines the methods to sync all missing headers by hash

type ImportStartHandler

type ImportStartHandler interface {
	ShouldStartImport() bool
	IsAfterExportBeforeImport() bool
	IsInterfaceNil() bool
}

ImportStartHandler can manage the process of starting the import after the hardfork event

type ManualEpochStartNotifier

type ManualEpochStartNotifier interface {
	RegisterHandler(handler ActionHandler)
	NewEpoch(epoch uint32)
	CurrentEpoch() uint32
	IsInterfaceNil() bool
}

ManualEpochStartNotifier represents a notifier that can be triggered manually for an epoch change event. Useful in storage resolvers (import-db process)

type MaxNodesChangeConfigProvider

type MaxNodesChangeConfigProvider interface {
	GetAllNodesConfig() []config.MaxNodesChangeConfig
	GetCurrentNodesConfig() config.MaxNodesChangeConfig
	EpochConfirmed(epoch uint32, round uint64)
	IsInterfaceNil() bool
}

MaxNodesChangeConfigProvider provides all config.MaxNodesChangeConfig, as well as the current config.MaxNodesChangeConfig based on the current epoch

type NodesConfigProvider

type NodesConfigProvider interface {
	ConsensusGroupSize(shardID uint32) int
	IsInterfaceNil() bool
}

NodesConfigProvider will provide the necessary information for start in epoch economics block creation

type Notifier

type Notifier interface {
	NotifyAll(hdr data.HeaderHandler)
	NotifyAllPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)
	NotifyEpochChangeConfirmed(epoch uint32)
	IsInterfaceNil() bool
}

Notifier defines which actions should be done for handling new epoch's events

type OwnerData

type OwnerData struct {
	NumStakedNodes int64
	NumActiveNodes int64
	TotalTopUp     *big.Int
	TopUpPerNode   *big.Int
	AuctionList    []state.ValidatorInfoHandler
	Qualified      bool
}

OwnerData is a struct containing relevant information about owner's nodes data

type PendingMiniBlocksSyncHandler

type PendingMiniBlocksSyncHandler interface {
	SyncPendingMiniBlocks(miniBlockHeaders []data.MiniBlockHeaderHandler, ctx context.Context) error
	GetMiniBlocks() (map[string]*block.MiniBlock, error)
	ClearFields()
	IsInterfaceNil() bool
}

PendingMiniBlocksSyncHandler defines the methods to sync all pending miniblocks

type RegistrationHandler

type RegistrationHandler interface {
	RegisterHandler(handler ActionHandler)
	UnregisterHandler(handler ActionHandler)
	IsInterfaceNil() bool
}

RegistrationHandler provides Register and Unregister functionality for the end of epoch events

type RequestHandler

type RequestHandler interface {
	RequestShardHeader(shardId uint32, hash []byte)
	RequestMetaHeader(hash []byte)
	RequestMetaHeaderByNonce(nonce uint64)
	RequestShardHeaderByNonce(shardId uint32, nonce uint64)
	RequestStartOfEpochMetaBlock(epoch uint32)
	RequestMiniBlocks(destShardID uint32, miniblocksHashes [][]byte)
	RequestInterval() time.Duration
	SetNumPeersToQuery(key string, intra int, cross int) error
	GetNumPeersToQuery(key string) (int, int, error)
	RequestValidatorInfo(hash []byte)
	RequestValidatorsInfo(hashes [][]byte)
	IsInterfaceNil() bool
}

RequestHandler defines the methods through which request to data can be made

type RewardsCreator

type RewardsCreator interface {
	CreateRewardsMiniBlocks(
		metaBlock data.MetaHeaderHandler, validatorsInfo state.ShardValidatorsInfoMapHandler, computedEconomics *block.Economics,
	) (block.MiniBlockSlice, error)
	VerifyRewardsMiniBlocks(
		metaBlock data.MetaHeaderHandler, validatorsInfo state.ShardValidatorsInfoMapHandler, computedEconomics *block.Economics,
	) error
	GetProtocolSustainabilityRewards() *big.Int
	GetLocalTxCache() TransactionCacher
	CreateMarshalledData(body *block.Body) map[string][][]byte
	GetRewardsTxs(body *block.Body) map[string]data.TransactionHandler
	SaveBlockDataToStorage(metaBlock data.MetaHeaderHandler, body *block.Body)
	DeleteBlockDataFromStorage(metaBlock data.MetaHeaderHandler, body *block.Body)
	RemoveBlockDataFromPools(metaBlock data.MetaHeaderHandler, body *block.Body)
	IsInterfaceNil() bool
}

RewardsCreator defines the functionality for the metachain to create rewards at end of epoch

type RoundHandler

type RoundHandler interface {
	// Index returns the current round
	Index() int64
	// TimeStamp returns the time stamp of the round
	TimeStamp() time.Time
	IsInterfaceNil() bool
}

RoundHandler defines the actions which should be handled by a round implementation

type StakingDataProvider

type StakingDataProvider interface {
	GetTotalStakeEligibleNodes() *big.Int
	GetTotalTopUpStakeEligibleNodes() *big.Int
	GetNodeStakedTopUp(blsKey []byte) (*big.Int, error)
	PrepareStakingData(validatorsMap state.ShardValidatorsInfoMapHandler) error
	FillValidatorInfo(validator state.ValidatorInfoHandler) error
	ComputeUnQualifiedNodes(validatorInfos state.ShardValidatorsInfoMapHandler) ([][]byte, map[string][][]byte, error)
	GetBlsKeyOwner(blsKey []byte) (string, error)
	GetNumOfValidatorsInCurrentEpoch() uint32
	GetCurrentEpochValidatorStats() ValidatorStatsInEpoch
	GetOwnersData() map[string]*OwnerData
	Clean()
	IsInterfaceNil() bool
}

StakingDataProvider is able to provide staking data from the system smart contracts

type StartOfEpochMetaSyncer

type StartOfEpochMetaSyncer interface {
	SyncEpochStartMeta(waitTime time.Duration) (data.MetaHeaderHandler, error)
	IsInterfaceNil() bool
}

StartOfEpochMetaSyncer defines the methods to synchronize epoch start meta block from the network when nothing is known

type TransactionCacher

type TransactionCacher interface {
	GetTx(txHash []byte) (data.TransactionHandler, error)
	IsInterfaceNil() bool
}

TransactionCacher defines the methods for the local transaction cacher, needed for the current block

type TriggerHandler

type TriggerHandler interface {
	Close() error
	ForceEpochStart(round uint64)
	IsEpochStart() bool
	Epoch() uint32
	MetaEpoch() uint32
	Update(round uint64, nonce uint64)
	EpochStartRound() uint64
	EpochStartMetaHdrHash() []byte
	GetSavedStateKey() []byte
	LoadState(key []byte) error
	SetProcessed(header data.HeaderHandler, body data.BodyHandler)
	SetFinalityAttestingRound(round uint64)
	EpochFinalityAttestingRound() uint64
	RevertStateToBlock(header data.HeaderHandler) error
	SetCurrentEpochStartRound(round uint64)
	RequestEpochStartIfNeeded(interceptedHeader data.HeaderHandler)
	IsInterfaceNil() bool
}

TriggerHandler defines the functionalities for an start of epoch trigger

type ValidatorInfoCacher

type ValidatorInfoCacher interface {
	GetValidatorInfo(validatorInfoHash []byte) (*state.ShardValidatorInfo, error)
	AddValidatorInfo(validatorInfoHash []byte, validatorInfo *state.ShardValidatorInfo)
	IsInterfaceNil() bool
}

ValidatorInfoCacher defines the methods for the local validator info cacher, needed for the current epoch

type ValidatorInfoCreator

type ValidatorInfoCreator interface {
	PeerAccountToValidatorInfo(peerAccount state.PeerAccountHandler) *state.ValidatorInfo
	IsInterfaceNil() bool
}

ValidatorInfoCreator defines the methods to create a validator info

type ValidatorStatsInEpoch

type ValidatorStatsInEpoch struct {
	Eligible map[uint32]int
	Waiting  map[uint32]int
	Leaving  map[uint32]int
}

ValidatorStatsInEpoch holds validator stats in an epoch