track

Documentation

Index

• Variables
• func NewBlockBalancer() (*blockBalancer, error)
• func NewBlockNotarizer(hasher hashing.Hasher, marshalizer marshal.Marshalizer, ...) (*blockNotarizer, error)
• func NewBlockNotifier() (*blockNotifier, error)
• func NewBlockProcessor(arguments ArgBlockProcessor) (*blockProcessor, error)
• func NewMetaBlockTrack(arguments ArgMetaTracker) (*metaBlockTrack, error)
• func NewMiniBlockTrack(dataPool dataRetriever.PoolsHolder, shardCoordinator sharding.Coordinator, ...) (*miniBlockTrack, error)
• func NewShardBlockTrack(arguments ArgShardTracker) (*shardBlockTrack, error)
• type ArgBaseTracker
• type ArgBlockProcessor
• type ArgMetaTracker
• type ArgShardTracker
• type HeaderInfo

Variables

var ErrNilBlockTrackerHandler = errors.New("nil block tracker handler")

ErrNilBlockTrackerHandler signals that a nil block tracker handler has been provided

var ErrNilCrossNotarizedHeadersNotifier = errors.New("nil cross notarized header notifier")

ErrNilCrossNotarizedHeadersNotifier signals that a nil block notifier handler has been provided

var ErrNilCrossNotarizer = errors.New("nil cross notarizer")

ErrNilCrossNotarizer signals that a nil block notarizer handler has been provided

var ErrNilFinalMetachainHeadersNotifier = errors.New("nil final metachain header notifier")

ErrNilFinalMetachainHeadersNotifier signals that a nil block notifier handler has been provided

var ErrNilRounder = errors.New("nil rounder")

ErrNilRounder signals that a nil rounder has been provided

var ErrNilSelfNotarizedFromCrossHeadersNotifier = errors.New("nil self notarized from cross header notifier")

ErrNilSelfNotarizedFromCrossHeadersNotifier signals that a nil block notifier handler has been provided

var ErrNilSelfNotarizedHeadersNotifier = errors.New("nil self notarized header notifier")

ErrNilSelfNotarizedHeadersNotifier signals that a nil block notifier handler has been provided

var ErrNilSelfNotarizer = errors.New("nil self notarizer")

ErrNilSelfNotarizer signals that a nil block notarizer handler has been provided

var ErrNotarizedHeaderOffsetIsOutOfBound = errors.New("requested offset of the notarized header is out of bound")

ErrNotarizedHeaderOffsetIsOutOfBound signals that a requested offset of the notarized header is out of bound

Functions

func NewBlockBalancer

func NewBlockBalancer() (*blockBalancer, error)

NewBlockBalancer creates a block balancer object which implements blockBalancerHandler interface

func NewBlockNotarizer

func NewBlockNotarizer(
	hasher hashing.Hasher,
	marshalizer marshal.Marshalizer,
	shardCoordinator sharding.Coordinator,
) (*blockNotarizer, error)

NewBlockNotarizer creates a block notarizer object which implements blockNotarizerHandler interface

func NewBlockNotifier

func NewBlockNotifier() (*blockNotifier, error)

NewBlockNotifier creates a block notifier object which implements blockNotifierHandler interface

func NewBlockProcessor

func NewBlockProcessor(arguments ArgBlockProcessor) (*blockProcessor, error)

NewBlockProcessor creates a block processor object which implements blockProcessorHandler interface

func NewMetaBlockTrack

func NewMetaBlockTrack(arguments ArgMetaTracker) (*metaBlockTrack, error)

NewMetaBlockTrack creates an object for tracking the received meta blocks

func NewMiniBlockTrack

func NewMiniBlockTrack(
	dataPool dataRetriever.PoolsHolder,
	shardCoordinator sharding.Coordinator,
	whitelistHandler process.WhiteListHandler,
) (*miniBlockTrack, error)

NewMiniBlockTrack creates an object for tracking the received mini blocks

func NewShardBlockTrack

func NewShardBlockTrack(arguments ArgShardTracker) (*shardBlockTrack, error)

NewShardBlockTrack creates an object for tracking the received shard blocks

Types

type ArgBaseTracker

type ArgBaseTracker struct {
	Hasher           hashing.Hasher
	HeaderValidator  process.HeaderConstructionValidator
	Marshalizer      marshal.Marshalizer
	RequestHandler   process.RequestHandler
	Rounder          process.Rounder
	ShardCoordinator sharding.Coordinator
	Store            dataRetriever.StorageService
	StartHeaders     map[uint32]data.HeaderHandler
	PoolsHolder      dataRetriever.PoolsHolder
	WhitelistHandler process.WhiteListHandler
}

ArgBaseTracker holds all dependencies required by the process data factory in order to create new instances of shard/meta block tracker

type ArgBlockProcessor

type ArgBlockProcessor struct {
	HeaderValidator                       process.HeaderConstructionValidator
	RequestHandler                        process.RequestHandler
	ShardCoordinator                      sharding.Coordinator
	BlockTracker                          blockTrackerHandler
	CrossNotarizer                        blockNotarizerHandler
	SelfNotarizer                         blockNotarizerHandler
	CrossNotarizedHeadersNotifier         blockNotifierHandler
	SelfNotarizedFromCrossHeadersNotifier blockNotifierHandler
	SelfNotarizedHeadersNotifier          blockNotifierHandler
	FinalMetachainHeadersNotifier         blockNotifierHandler
	Rounder                               process.Rounder
}

ArgBlockProcessor holds all dependencies required to process tracked blocks in order to create new instances of block processor

type ArgMetaTracker

type ArgMetaTracker struct {
	ArgBaseTracker
}

ArgMetaTracker holds all dependencies required by the process data factory in order to create new instances of meta block tracker

type ArgShardTracker

type ArgShardTracker struct {
	ArgBaseTracker
}

ArgShardTracker holds all dependencies required by the process data factory in order to create new instances of shard block tracker

type HeaderInfo

type HeaderInfo struct {
	Hash   []byte
	Header data.HeaderHandler
}

HeaderInfo holds the information about a header