chain

package
v1.22.2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 28, 2023 License: Apache-2.0, MIT Imports: 44 Imported by: 11

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	BootstrapPeerThreshold = build.BootstrapPeerThreshold

	RecentSyncBufferSize = 10
	MaxSyncWorkers       = 5
	SyncWorkerHistory    = 3

	InitialSyncTimeThreshold = 15 * time.Minute
)
View Source
var ErrForkCheckpoint = fmt.Errorf("fork would require us to diverge from checkpointed block")
View Source
var ErrForkTooLong = fmt.Errorf("fork longer than threshold")
View Source
var (
	// LocalIncoming is the _local_ pubsub (unrelated to libp2p pubsub) topic
	// where the Syncer publishes candidate chain heads to be synced.
	LocalIncoming = "incoming"
)

Functions

func AuthenticateMessage added in v1.20.0

func AuthenticateMessage(msg *types.SignedMessage, signer address.Address) error

AuthenticateMessage authenticates the message by verifying that the supplied SignedMessage was signed by the indicated Address, computing the correct signature payload depending on the signature type. The supplied Address type must be recognized by the registered verifier for the signature type.

func IsValidSecpkSigType added in v1.20.0

func IsValidSecpkSigType(nv network.Version, typ crypto.SigType) bool

IsValidSecpkSigType checks that a signature type is valid for the network version, for a "secpk" message.

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)

func (*BadBlockCache) Purge added in v0.10.0

func (bts *BadBlockCache) Purge()

func (*BadBlockCache) Remove added in v0.6.2

func (bts *BadBlockCache) Remove(c cid.Cid)

type BadBlockReason added in v0.5.0

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

func NewBadBlockReason added in v0.5.0

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

func (BadBlockReason) Linked added in v0.5.0

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

func (BadBlockReason) String added in v0.5.0

func (bbr BadBlockReason) String() string

type Genesis added in v1.11.3

type Genesis *types.TipSet

func LoadGenesis added in v1.11.3

func LoadGenesis(ctx context.Context, sm *stmgr.StateManager) (Genesis, error)

type SyncFunc

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

type SyncManager

type SyncManager interface {
	// Start starts the SyncManager.
	Start()

	// Stop stops the SyncManager.
	Stop()

	// SetPeerHead informs the SyncManager that the supplied peer reported the
	// supplied tipset.
	SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet)

	// State retrieves the state of the sync workers.
	State() []SyncerStateSnapshot
}

SyncManager manages the chain synchronization process, both at bootstrap time and during ongoing operation.

It receives candidate chain heads in the form of tipsets from peers, and schedules them onto sync workers, deduplicating processing for already-active syncs.

func NewSyncManager

func NewSyncManager(sync SyncFunc) SyncManager

sync manager interface

type SyncManagerCtor added in v0.7.1

type SyncManagerCtor func(syncFn SyncFunc) SyncManager

type Syncer

type Syncer struct {

	// The known Genesis tipset
	Genesis *types.TipSet

	// handle to the block sync service
	Exchange exchange.Client
	// 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), ChainExchange, 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(ds dtypes.MetadataDS,
	sm *stmgr.StateManager,
	exchange exchange.Client,
	syncMgrCtor SyncManagerCtor,
	connmgr connmgr.ConnManager,
	self peer.ID,
	beacon beacon.Schedule,
	gent Genesis,
	consensus consensus.Consensus) (*Syncer, error)

NewSyncer creates a new Syncer object.

func (*Syncer) ChainStore

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

func (*Syncer) CheckBadBlockCache added in v0.2.8

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 (client) 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) LocalPeer

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

func (*Syncer) MarkBad added in v0.1.6

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() []SyncerStateSnapshot

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) SyncCheckpoint added in v1.11.0

func (syncer *Syncer) SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error

func (*Syncer) UnmarkAllBad added in v0.10.0

func (syncer *Syncer) UnmarkAllBad()

func (*Syncer) UnmarkBad added in v0.6.2

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

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

func (*Syncer) ValidateBlock

func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock, useCache bool) (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, useCache bool) error

type SyncerState

type SyncerState struct {
	// 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() SyncerStateSnapshot

type SyncerStateSnapshot added in v0.10.0

type SyncerStateSnapshot struct {
	WorkerID uint64
	Target   *types.TipSet
	Base     *types.TipSet
	Stage    api.SyncStateStage
	Height   abi.ChainEpoch
	Message  string
	Start    time.Time
	End      time.Time
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL