protocol

Documentation

Index

• Constants
• Variables
• func NewMockBlockchain(headers []*types.Header) *mockBlockchain
• type Blockchain
• type NoForkPeer
  • func (p *NoForkPeer) IsBetter(t *NoForkPeer) bool
• type PeerMap
  • func NewPeerMap(peers []*NoForkPeer) *PeerMap
  • func (m *PeerMap) BestPeer(skipMap *map[peer.ID]int64) *NoForkPeer
  • func (m *PeerMap) Exists(peerID peer.ID) bool
  • func (m *PeerMap) Put(peers ...*NoForkPeer)
  • func (m *PeerMap) Remove(peerID peer.ID)
• type Progression
• type Status
  • func HeaderToStatus(h *types.Header) *Status
  • func (s *Status) Copy() *Status
• type SyncPeerClient
  • func NewSyncPeerClient(logger hclog.Logger, network network.Network, blockchain Blockchain) SyncPeerClient
• type SyncPeerService
  • func NewSyncPeerService(network network.Network, blockchain Blockchain) SyncPeerService
• type Syncer
  • func NewSyncer(logger hclog.Logger, server network.Network, blockchain Blockchain, ...) Syncer

Constants

const (
	SyncPeerClientLoggerName = "sync-peer-client"
)

const (
	WriteBlockSource = "syncer"
)

Variables

var (
	ErrLoadLocalGenesisFailed = errors.New("failed to read local genesis")
	ErrMismatchGenesis        = errors.New("genesis does not match")
	ErrCommonAncestorNotFound = errors.New("header is nil")
	ErrForkNotFound           = errors.New("fork not found")
	ErrPopTimeout             = errors.New("timeout")
	ErrConnectionClosed       = errors.New("connection closed")
	ErrTooManyHeaders         = errors.New("unexpected more than 1 result")
	ErrDecodeDifficulty       = errors.New("failed to decode difficulty")
	ErrInvalidTypeAssertion   = errors.New("invalid type assertion")
	ErrBlockVerifyFailed      = errors.New("block verifying failed")
)

Functions

func NewMockBlockchain

func NewMockBlockchain(headers []*types.Header) *mockBlockchain

Types

type Blockchain

type Blockchain interface {
	// SubscribeEvents subscribes new blockchain event
	SubscribeEvents() blockchain.Subscription
	Header() *types.Header

	// deprecated methods. Those are old version protocols, keep it only for backward compatible
	CurrentTD() *big.Int
	GetTD(hash types.Hash) (*big.Int, bool)
	GetReceiptsByHash(types.Hash) ([]*types.Receipt, error)
	GetBodyByHash(types.Hash) (*types.Body, bool)
	GetHeaderByHash(types.Hash) (*types.Header, bool)
	GetHeaderByNumber(n uint64) (*types.Header, bool)
	CalculateGasLimit(number uint64) (uint64, error)

	// advance chain methods
	WriteBlock(block *types.Block, source string) error
	VerifyFinalizedBlock(block *types.Block) error

	// GetBlockByNumber returns block by number
	GetBlockByNumber(uint64, bool) (*types.Block, bool)
}

Blockchain is the interface required by the syncer to connect to the blockchain

type NoForkPeer

type NoForkPeer struct {
	// identifier
	ID peer.ID
	// peer's latest block number
	Number uint64
}

func (*NoForkPeer) IsBetter

func (p *NoForkPeer) IsBetter(t *NoForkPeer) bool

type PeerMap

type PeerMap struct {
	sync.Map
}

func NewPeerMap

func NewPeerMap(peers []*NoForkPeer) *PeerMap

func (*PeerMap) BestPeer

func (m *PeerMap) BestPeer(skipMap *map[peer.ID]int64) *NoForkPeer

BestPeer returns the top of heap

func (*PeerMap) Exists

func (m *PeerMap) Exists(peerID peer.ID) bool

func (*PeerMap) Put

func (m *PeerMap) Put(peers ...*NoForkPeer)

func (*PeerMap) Remove

func (m *PeerMap) Remove(peerID peer.ID)

Remove removes a peer from heap if it exists

type Progression

type Progression interface {
	// StartProgression starts progression
	StartProgression(syncingPeer string, startingBlock uint64, subscription blockchain.Subscription)
	// UpdateHighestProgression updates highest block number
	UpdateHighestProgression(highestBlock uint64)
	// GetProgression returns Progression
	GetProgression() *progress.Progression
	// StopProgression finishes progression
	StopProgression()
}

type Status

type Status struct {
	Difficulty *big.Int   // Current difficulty
	Hash       types.Hash // Latest block hash
	Number     uint64     // Latest block number
}

Status defines the up to date information regarding the peer

func HeaderToStatus

func HeaderToStatus(h *types.Header) *Status

HeaderToStatus converts given header to Status

func (*Status) Copy

func (s *Status) Copy() *Status

Copy creates a copy of the status

type SyncPeerClient

type SyncPeerClient interface {
	// Start processes for SyncPeerClient
	Start() error
	// Close terminates running processes for SyncPeerClient
	Close()
	// GetPeerStatus fetches peer status
	GetPeerStatus(id peer.ID) (*NoForkPeer, error)
	// GetConnectedPeerStatuses fetches the statuses of all connecting peers
	GetConnectedPeerStatuses() []*NoForkPeer
	// GetBlocks returns a stream of blocks from given height to peer's latest
	GetBlocks(ctx context.Context, peerID peer.ID, from uint64, to uint64) ([]*types.Block, error)
	// GetPeerStatusUpdateCh returns a channel of peer's status update
	GetPeerStatusUpdateCh() <-chan *NoForkPeer
	// GetPeerConnectionUpdateEventCh returns peer's connection change event
	GetPeerConnectionUpdateEventCh() <-chan *event.PeerEvent
	// DisablePublishingPeerStatus disables publishing status in syncer topic
	DisablePublishingPeerStatus()
	// EnablePublishingPeerStatus enables publishing status in syncer topic
	EnablePublishingPeerStatus()

	// broadcast block to all its connected peers
	Broadcast(block *types.Block) error
}

func NewSyncPeerClient

func NewSyncPeerClient(
	logger hclog.Logger,
	network network.Network,
	blockchain Blockchain,
) SyncPeerClient

type SyncPeerService

type SyncPeerService interface {
	// Start starts server
	Start()
	// Close terminates running processes for SyncPeerService
	Close() error

	// SetSyncer sets referent syncer
	SetSyncer(syncer *noForkSyncer)
}

func NewSyncPeerService

func NewSyncPeerService(
	network network.Network,
	blockchain Blockchain,
) SyncPeerService

type Syncer

type Syncer interface {
	// Start starts syncer processes
	Start() error
	// Close terminates syncer process
	Close() error
	// GetSyncProgression returns sync progression
	GetSyncProgression() *progress.Progression
	// HasSyncPeer returns whether syncer has the peer syncer can sync with
	HasSyncPeer() bool
	// IsSyncing returns whether syncer is syncing
	IsSyncing() bool
	// Sync starts routine to sync blocks
	Sync(func(*types.Block) bool) error
}

Syncer is a sync protocol for block downloading

func NewSyncer

func NewSyncer(
	logger hclog.Logger,
	server network.Network,
	blockchain Blockchain,
	enableBlockBroadcast bool,
) Syncer

NewSyncer creates a new Syncer instance