chain

Documentation

Index

• Constants
• Variables
• func SyncStageString(v api.SyncStateStage) string
• func VerifyElectionPoStVRF(ctx context.Context, worker address.Address, rand []byte, evrf []byte) error
• type BadBlockCache
  • func NewBadBlockCache() *BadBlockCache
  • func (bts *BadBlockCache) Add(c cid.Cid, bbr BadBlockReason)
  • func (bts *BadBlockCache) Has(c cid.Cid) (BadBlockReason, bool)
• type BadBlockReason
  • func NewBadBlockReason(cid []cid.Cid, format string, i ...interface{}) BadBlockReason
  • func (bbr BadBlockReason) Linked(reason string, i ...interface{}) BadBlockReason
  • func (bbr BadBlockReason) String() string
• type SyncFunc
• type SyncManager
  • func NewSyncManager(sync SyncFunc) *SyncManager
  • func (sm *SyncManager) IsBootstrapped() bool
  • func (sm *SyncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet)
  • func (sm *SyncManager) Start()
  • func (sm *SyncManager) Stop()
• type Syncer
  • func NewSyncer(sm *stmgr.StateManager, bsync *blocksync.BlockSync, ...) (*Syncer, error)
  • func (syncer *Syncer) ChainStore() *store.ChainStore
  • func (syncer *Syncer) CheckBadBlockCache(blk cid.Cid) (string, bool)
  • func (syncer *Syncer) FetchTipSet(ctx context.Context, p peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error)
  • func (syncer *Syncer) IncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error)
  • func (syncer *Syncer) InformNewBlock(from peer.ID, blk *types.FullBlock) bool
  • func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool
  • func (syncer *Syncer) IsEpochBeyondCurrMax(epoch abi.ChainEpoch) bool
  • func (syncer *Syncer) LocalPeer() peer.ID
  • func (syncer *Syncer) MarkBad(blk cid.Cid)
  • func (syncer *Syncer) Start()
  • func (syncer *Syncer) State() []SyncerState
  • func (syncer *Syncer) Stop()
  • func (syncer *Syncer) Sync(ctx context.Context, maybeHead *types.TipSet) error
  • func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (err error)
  • func (syncer *Syncer) ValidateMsgMeta(fblk *types.FullBlock) error
  • func (syncer *Syncer) ValidateTipSet(ctx context.Context, fts *store.FullTipSet) error
  • func (syncer *Syncer) VerifyWinningPoStProof(ctx context.Context, h *types.BlockHeader, prevBeacon types.BeaconEntry, ...) error
• type SyncerState
  • func (ss *SyncerState) Error(err error)
  • func (ss *SyncerState) Init(base, target *types.TipSet)
  • func (ss *SyncerState) SetHeight(h abi.ChainEpoch)
  • func (ss *SyncerState) SetStage(v api.SyncStateStage)
  • func (ss *SyncerState) Snapshot() SyncerState

Constants

const (
	BSStateInit      = 0
	BSStateSelected  = 1
	BSStateScheduled = 2
	BSStateComplete  = 3
)

const BootstrapPeerThreshold = 2

const MaxHeightDrift = 5

Blocks that are more than MaxHeightDrift epochs above the theoretical max height based on systime are quickly rejected

Variables

var ErrForkTooLong = fmt.Errorf("fork longer than threshold")

var ErrTemporal = errors.New("temporal error")

var LocalIncoming = "incoming"

Functions

func SyncStageString

func SyncStageString(v api.SyncStateStage) string

func VerifyElectionPoStVRF

func VerifyElectionPoStVRF(ctx context.Context, worker address.Address, rand []byte, evrf []byte) error

Types

type BadBlockCache

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

func NewBadBlockCache

func NewBadBlockCache() *BadBlockCache

func (*BadBlockCache) Add

func (bts *BadBlockCache) Add(c cid.Cid, bbr BadBlockReason)

func (*BadBlockCache) Has

func (bts *BadBlockCache) Has(c cid.Cid) (BadBlockReason, bool)

type BadBlockReason

type BadBlockReason struct {
	Reason         string
	TipSet         []cid.Cid
	OriginalReason *BadBlockReason
}

func NewBadBlockReason

func NewBadBlockReason(cid []cid.Cid, format string, i ...interface{}) BadBlockReason

func (BadBlockReason) Linked

func (bbr BadBlockReason) Linked(reason string, i ...interface{}) BadBlockReason

func (BadBlockReason) String

func (bbr BadBlockReason) String() string

type SyncFunc

type SyncFunc func(context.Context, *types.TipSet) error

type SyncManager

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

func NewSyncManager

func NewSyncManager(sync SyncFunc) *SyncManager

func (*SyncManager) IsBootstrapped

func (sm *SyncManager) IsBootstrapped() bool

func (*SyncManager) SetPeerHead

func (sm *SyncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet)

func (*SyncManager) Start

func (sm *SyncManager) Start()

func (*SyncManager) Stop

func (sm *SyncManager) Stop()

type Syncer

type Syncer struct {

	// The known Genesis tipset
	Genesis *types.TipSet

	// handle to the block sync service
	Bsync *blocksync.BlockSync
	// contains filtered or unexported fields
}

Syncer is in charge of running the chain synchronization logic. As such, it is tasked with these functions, amongst others:

• Fast-forwards the chain as it learns of new TipSets from the network via the SyncManager.
• Applies the fork choice rule to select the correct side when confronted with a fork in the network.
• Requests block headers and messages from other peers when not available in our BlockStore.
• Tracks blocks marked as bad in a cache.
• Keeps the BlockStore and ChainStore consistent with our view of the world, the latter of which in turn informs other components when a reorg has been committed.

The Syncer does not run workers itself. It's mainly concerned with ensuring a consistent state of chain consensus. The reactive and network- interfacing processes are part of other components, such as the SyncManager (which owns the sync scheduler and sync workers), BlockSync, the HELLO protocol, and the gossipsub block propagation layer.

{hint/concept} The fork-choice rule as it currently stands is: "pick the chain with the heaviest weight, so long as it hasn’t deviated one finality threshold from our head (900 epochs, parameter determined by spec-actors)".

func NewSyncer

func NewSyncer(sm *stmgr.StateManager, bsync *blocksync.BlockSync, connmgr connmgr.ConnManager, self peer.ID, beacon beacon.RandomBeacon, verifier ffiwrapper.Verifier) (*Syncer, error)

NewSyncer creates a new Syncer object.

func (*Syncer) ChainStore

func (syncer *Syncer) ChainStore() *store.ChainStore

func (*Syncer) CheckBadBlockCache

func (syncer *Syncer) CheckBadBlockCache(blk cid.Cid) (string, bool)

func (*Syncer) FetchTipSet

func (syncer *Syncer) FetchTipSet(ctx context.Context, p peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error)

FetchTipSet tries to load the provided tipset from the store, and falls back to the network (BlockSync) by querying the supplied peer if not found locally.

{hint/usage} This is used from the HELLO protocol, to fetch the greeting peer's heaviest tipset if we don't have it.

func (*Syncer) IncomingBlocks

func (syncer *Syncer) IncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error)

IncomingBlocks spawns a goroutine that subscribes to the local eventbus to receive new block headers as they arrive from the network, and sends them to the returned channel.

These blocks have not necessarily been incorporated to our view of the chain.

func (*Syncer) InformNewBlock

func (syncer *Syncer) InformNewBlock(from peer.ID, blk *types.FullBlock) bool

func (*Syncer) InformNewHead

func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool

InformNewHead informs the syncer about a new potential tipset This should be called when connecting to new peers, and additionally when receiving new blocks from the network

func (*Syncer) IsEpochBeyondCurrMax

func (syncer *Syncer) IsEpochBeyondCurrMax(epoch abi.ChainEpoch) bool

func (*Syncer) LocalPeer

func (syncer *Syncer) LocalPeer() peer.ID

func (*Syncer) MarkBad

func (syncer *Syncer) MarkBad(blk cid.Cid)

MarkBad manually adds a block to the "bad blocks" cache.

func (*Syncer) Start

func (syncer *Syncer) Start()

func (*Syncer) State

func (syncer *Syncer) State() []SyncerState

func (*Syncer) Stop

func (syncer *Syncer) Stop()

func (*Syncer) Sync

func (syncer *Syncer) Sync(ctx context.Context, maybeHead *types.TipSet) error

Sync tries to advance our view of the chain to `maybeHead`. It does nothing if our current head is heavier than the requested tipset, or if we're already at the requested head, or if the head is the genesis.

Most of the heavy-lifting logic happens in syncer#collectChain. Refer to the godocs on that method for a more detailed view.

func (*Syncer) ValidateBlock

func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (err error)

ValidateBlock should match up with 'Semantical Validation' in validation.md in the spec

func (*Syncer) ValidateMsgMeta

func (syncer *Syncer) ValidateMsgMeta(fblk *types.FullBlock) error

ValidateMsgMeta performs structural and content hash validation of the messages within this block. If validation passes, it stores the messages in the underlying IPLD block store.

func (*Syncer) ValidateTipSet

func (syncer *Syncer) ValidateTipSet(ctx context.Context, fts *store.FullTipSet) error

func (*Syncer) VerifyWinningPoStProof

func (syncer *Syncer) VerifyWinningPoStProof(ctx context.Context, h *types.BlockHeader, prevBeacon types.BeaconEntry, lbst cid.Cid, waddr address.Address) error

type SyncerState

type SyncerState struct {
	Target  *types.TipSet
	Base    *types.TipSet
	Stage   api.SyncStateStage
	Height  abi.ChainEpoch
	Message string
	Start   time.Time
	End     time.Time
	// contains filtered or unexported fields
}

func (*SyncerState) Error

func (ss *SyncerState) Error(err error)

func (*SyncerState) Init

func (ss *SyncerState) Init(base, target *types.TipSet)

func (*SyncerState) SetHeight

func (ss *SyncerState) SetHeight(h abi.ChainEpoch)

func (*SyncerState) SetStage

func (ss *SyncerState) SetStage(v api.SyncStateStage)

func (*SyncerState) Snapshot

func (ss *SyncerState) Snapshot() SyncerState