chain

package
v1.20.0-hyperspace-nv2... Latest Latest
Warning

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

 Go to latest Published: Feb 15, 2023 License: Apache-2.0, MIT Imports: 45 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, nv network.Version) 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
}

Source Files

View all Source files

Directories

Path Synopsis
adt
aerrors
agen
builtin
builtin/account
builtin/cron
builtin/datacap
builtin/evm
builtin/init
builtin/market
builtin/miner
builtin/multisig
builtin/paych
builtin/paych/mock
builtin/power
builtin/reward
builtin/system
builtin/verifreg
policy
drand
filcns
filter
state
state/mock
Package exchange contains the ChainExchange server and client components.
 Package exchange contains the ChainExchange server and client components.
gen
genesis
slashfilter
gasguess
rpc
sub
ratelimit
ethtypes
mock
gen
key
ledger
remotewallet

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.