inmem

package
v0.37.22 Latest Latest
Warning

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

 Go to latest Published: Nov 21, 2024 License: AGPL-3.0 Imports: 14 Imported by: 10

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ClusteringFromSetupEvent added in v0.26.1 

func ClusteringFromSetupEvent(setupEvent *flow.EpochSetup) (flow.ClusterList, error)

func EpochProtocolStateFromServiceEvents added in v0.33.30 

func EpochProtocolStateFromServiceEvents(setup *flow.EpochSetup, commit *flow.EpochCommit) *flow.MinEpochStateEntry

EpochProtocolStateFromServiceEvents generates a protocol.MinEpochStateEntry for a root protocol state which is used for bootstrapping.

CONTEXT: The EpochSetup event contains the IdentitySkeletons for each participant, thereby specifying active epoch members. While ejection status is not part of the EpochSetup event, we can supplement this information as follows:

  • Per convention, service events are delivered (asynchronously) in an *order-preserving* manner. Furthermore, node ejection is also mediated by system smart contracts and delivered via service events.
  • Therefore, the EpochSetup event contains the up-to-date snapshot of the epoch participants. Any node ejection that happened before should be reflected in the EpochSetup event. Specifically, ejected nodes should be no longer listed in the EpochSetup event. Hence, when the EpochSetup event is emitted / processed, the ejected flag is false for all epoch participants.

func NewCommittedEpoch 

func NewCommittedEpoch(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit) protocol.Epoch

NewCommittedEpoch returns a memory-backed epoch implementation based on an EpochSetup and EpochCommit events. No errors are expected during normal operations.

func NewEpochWithEndBoundary added in v0.33.30 

func NewEpochWithEndBoundary(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit, finalHeight uint64) protocol.Epoch

NewEpochWithEndBoundary returns a memory-backed epoch implementation based on an EpochSetup and EpochCommit events, and the epoch's final block height (end boundary). No errors are expected during normal operations.

func NewEpochWithStartAndEndBoundaries added in v0.33.30 

func NewEpochWithStartAndEndBoundaries(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit, firstHeight, finalHeight uint64) protocol.Epoch

NewEpochWithStartAndEndBoundaries returns a memory-backed epoch implementation based on an EpochSetup and EpochCommit events, and the epoch's first and final block heights (start+end boundaries). No errors are expected during normal operations.

func NewEpochWithStartBoundary added in v0.33.30 

func NewEpochWithStartBoundary(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit, firstHeight uint64) protocol.Epoch

NewEpochWithStartBoundary returns a memory-backed epoch implementation based on an EpochSetup and EpochCommit events, and the epoch's first block height (start boundary). No errors are expected during normal operations.

func NewSetupEpoch 

func NewSetupEpoch(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension) protocol.Epoch

NewSetupEpoch returns a memory-backed epoch implementation based on an EpochSetup event. Epoch information available after the setup phase will not be accessible in the resulting epoch instance. No errors are expected during normal operations.

Types

type Cluster 

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

func ClusterFromEncodable 

func ClusterFromEncodable(enc EncodableCluster) (*Cluster, error)

ClusterFromEncodable returns a Cluster backed by the given encodable representation.

func (Cluster) ChainID 

func (c Cluster) ChainID() flow.ChainID

func (Cluster) EpochCounter 

func (c Cluster) EpochCounter() uint64

func (Cluster) Index 

func (c Cluster) Index() uint

func (Cluster) Members 

func (c Cluster) Members() flow.IdentitySkeletonList

func (Cluster) RootBlock 

func (c Cluster) RootBlock() *clustermodel.Block

func (Cluster) RootQC 

func (c Cluster) RootQC() *flow.QuorumCertificate

type DKG 

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

TODO(EFM, #6214): Once EpochCommit.DKGIndexMap is populated, we can remove much of the logic here.

  • a thin wrapper around EpochCommit can satisfy the protocol.DKG interface

func DKGFromEncodable 

func DKGFromEncodable(enc EncodableDKG) (*DKG, error)

DKGFromEncodable returns a DKG backed by the given encodable representation.

func NewDKG added in v0.33.30 

func NewDKG(enc EncodableDKG) *DKG

func (DKG) GroupKey 

func (d DKG) GroupKey() crypto.PublicKey

func (DKG) Index 

func (d DKG) Index(nodeID flow.Identifier) (uint, error)

Index returns the index for the given node. Error Returns: protocol.IdentityNotFoundError if nodeID is not a valid DKG participant.

func (DKG) KeyShare 

func (d DKG) KeyShare(nodeID flow.Identifier) (crypto.PublicKey, error)

KeyShare returns the public key share for the given node. Error Returns: protocol.IdentityNotFoundError if nodeID is not a valid DKG participant.

func (DKG) Size 

func (d DKG) Size() uint

type EncodableCluster 

type EncodableCluster struct {
	Index     uint
	Counter   uint64
	Members   flow.IdentitySkeletonList
	RootBlock *cluster.Block
	RootQC    *flow.QuorumCertificate
}

EncodableCluster is the encoding format for protocol.Cluster

type EncodableDKG 

type EncodableDKG struct {
	GroupKey     encodable.RandomBeaconPubKey
	Participants map[flow.Identifier]flow.DKGParticipant
}

EncodableDKG is the encoding format for protocol.DKG

func EncodableDKGFromEvents added in v0.33.30 

func EncodableDKGFromEvents(setup *flow.EpochSetup, commit *flow.EpochCommit) (EncodableDKG, error)

EncodableDKGFromEvents returns an EncodableDKG constructed from epoch setup and commit events. No errors are expected during normal operations.

type EncodableFullDKG added in v0.22.8 

type EncodableFullDKG struct {
	GroupKey      encodable.RandomBeaconPubKey
	PrivKeyShares []encodable.RandomBeaconPrivKey
	PubKeyShares  []encodable.RandomBeaconPubKey
}

type EncodableParams added in v0.23.2 

type EncodableParams struct {
	ChainID              flow.ChainID
	SporkID              flow.Identifier
	SporkRootBlockHeight uint64
	ProtocolVersion      uint
}

EncodableParams is the encoding format for protocol.GlobalParams

type EncodableSnapshot 

type EncodableSnapshot struct {
	SealingSegment      *flow.SealingSegment
	QuorumCertificate   *flow.QuorumCertificate
	Params              EncodableParams
	SealedVersionBeacon *flow.SealedVersionBeacon
}

EncodableSnapshot is the encoding format for protocol.Snapshot

func (EncodableSnapshot) Head 

func (snap EncodableSnapshot) Head() *flow.Header

Head returns the latest finalized header of the Snapshot, which is the block in the sealing segment with the greatest Height. The EncodableSnapshot receiver must be correctly formed.

func (EncodableSnapshot) LatestSeal 

func (snap EncodableSnapshot) LatestSeal() (*flow.Seal, error)

LatestSeal returns the latest seal of the Snapshot. This is the seal for the block with the greatest height, of all seals in the Snapshot. The EncodableSnapshot receiver must be correctly formed. No errors are expected during normal operation.

func (EncodableSnapshot) LatestSealedResult added in v0.33.30 

func (snap EncodableSnapshot) LatestSealedResult() (*flow.ExecutionResult, error)

LatestSealedResult returns the latest sealed result of the Snapshot. This is the result which is sealed by LatestSeal. The EncodableSnapshot receiver must be correctly formed. No errors are expected during normal operation.

type EpochProtocolStateAdapter added in v0.33.30 

type EpochProtocolStateAdapter struct {
	*flow.RichEpochStateEntry
	// contains filtered or unexported fields
}

EpochProtocolStateAdapter implements protocol.EpochProtocolState by wrapping a flow.RichEpochStateEntry.

func NewEpochProtocolStateAdapter added in v0.33.30 

func NewEpochProtocolStateAdapter(entry *flow.RichEpochStateEntry, params protocol.GlobalParams) *EpochProtocolStateAdapter

func (*EpochProtocolStateAdapter) Clustering added in v0.33.30 

func (s *EpochProtocolStateAdapter) Clustering() (flow.ClusterList, error)

Clustering returns the cluster assignment for the current epoch. No errors are expected during normal operations.

func (*EpochProtocolStateAdapter) DKG added in v0.33.30 

func (s *EpochProtocolStateAdapter) DKG() (protocol.DKG, error)

DKG returns the DKG information for the current epoch. No errors are expected during normal operations.

func (*EpochProtocolStateAdapter) Entry added in v0.33.30 

func (s *EpochProtocolStateAdapter) Entry() *flow.RichEpochStateEntry

Entry Returns low-level protocol state entry that was used to initialize this object. It shouldn't be used by high-level logic, it is useful for some cases such as bootstrapping. Prefer using other methods to access protocol state.

func (*EpochProtocolStateAdapter) Epoch added in v0.33.30 

func (s *EpochProtocolStateAdapter) Epoch() uint64

Epoch returns the current epoch counter.

func (*EpochProtocolStateAdapter) EpochCommit added in v0.33.30 

func (s *EpochProtocolStateAdapter) EpochCommit() *flow.EpochCommit

EpochCommit returns the flow.EpochCommit service event which partly defines the initial epoch state for the current epoch.

func (*EpochProtocolStateAdapter) EpochExtensions added in v0.37.1 

func (s *EpochProtocolStateAdapter) EpochExtensions() []flow.EpochExtension

EpochExtensions returns the epoch extensions associated with the current epoch, if any.

func (*EpochProtocolStateAdapter) EpochFallbackTriggered added in v0.37.1 

func (s *EpochProtocolStateAdapter) EpochFallbackTriggered() bool

EpochFallbackTriggered denotes whether an invalid epoch state transition was attempted on the fork ending this block. Once the first block where this flag is true is finalized, epoch fallback mode is triggered. TODO for 'leaving Epoch Fallback via special service event': at the moment, this is a one-way transition and requires a spork to recover - need to revisit for sporkless EFM recovery

func (*EpochProtocolStateAdapter) EpochPhase added in v0.33.30 

func (s *EpochProtocolStateAdapter) EpochPhase() flow.EpochPhase

EpochPhase returns the epoch phase for the current epoch. The receiver must be properly constructed. See flow.EpochPhase for detailed documentation.

func (*EpochProtocolStateAdapter) EpochSetup added in v0.33.30 

func (s *EpochProtocolStateAdapter) EpochSetup() *flow.EpochSetup

EpochSetup returns the flow.EpochSetup service event which partly defines the initial epoch state for the current epoch.

func (*EpochProtocolStateAdapter) GlobalParams added in v0.33.30 

func (s *EpochProtocolStateAdapter) GlobalParams() protocol.GlobalParams

GlobalParams returns spork-scoped global network parameters.

func (*EpochProtocolStateAdapter) Identities added in v0.33.30 

func (s *EpochProtocolStateAdapter) Identities() flow.IdentityList

Identities returns the identity table as of the current block.

func (*EpochProtocolStateAdapter) PreviousEpochExists added in v0.33.30 

func (s *EpochProtocolStateAdapter) PreviousEpochExists() bool

PreviousEpochExists returns true if a previous epoch exists. This is true for all epoch except those immediately following a spork.

type Epochs 

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

Epochs provides access to epoch data, backed by a rich epoch protocol state entry.

func (Epochs) Current 

func (eq Epochs) Current() protocol.Epoch

func (Epochs) Next 

func (eq Epochs) Next() protocol.Epoch

func (Epochs) Previous 

func (eq Epochs) Previous() protocol.Epoch

type Params added in v0.23.2 

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

func FromParams added in v0.23.2 

func FromParams(from protocol.GlobalParams) (*Params, error)

FromParams converts any protocol.GlobalParams to a memory-backed Params. TODO error docs

func NewParams added in v0.33.30 

func NewParams(enc EncodableParams) *Params

func (Params) ChainID added in v0.23.2 

func (p Params) ChainID() flow.ChainID

func (Params) ProtocolVersion added in v0.23.2 

func (p Params) ProtocolVersion() uint

func (Params) SporkID added in v0.23.2 

func (p Params) SporkID() flow.Identifier

func (Params) SporkRootBlockHeight added in v0.29.6 

func (p Params) SporkRootBlockHeight() uint64

type Snapshot 

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

Snapshot is a memory-backed implementation of protocol.Snapshot. The snapshot data is stored in the embedded encodable snapshot model, which defines the canonical structure of an encoded snapshot for the purposes of serialization.

func FromSnapshot 

func FromSnapshot(from protocol.Snapshot) (*Snapshot, error)

FromSnapshot generates a memory-backed snapshot from the input snapshot. Typically, this would be used to convert a database-backed snapshot to one that can easily be serialized to disk or to network. TODO error docs

func SnapshotFromBootstrapState 

func SnapshotFromBootstrapState(root *flow.Block, result *flow.ExecutionResult, seal *flow.Seal, qc *flow.QuorumCertificate) (*Snapshot, error)

SnapshotFromBootstrapState generates a protocol.Snapshot representing a root bootstrap state. This is used to bootstrap the protocol state for genesis or post-spork states.

func SnapshotFromBootstrapStateWithParams added in v0.29.0 

func SnapshotFromBootstrapStateWithParams(
	root *flow.Block,
	result *flow.ExecutionResult,
	seal *flow.Seal,
	qc *flow.QuorumCertificate,
	protocolVersion uint,
	kvStoreFactory func(epochStateID flow.Identifier) (protocol_state.KVStoreAPI, error),
) (*Snapshot, error)

SnapshotFromBootstrapStateWithParams is SnapshotFromBootstrapState with a caller-specified protocol version.

func SnapshotFromEncodable 

func SnapshotFromEncodable(enc EncodableSnapshot) *Snapshot

func (Snapshot) Commit 

func (s Snapshot) Commit() (flow.StateCommitment, error)

func (Snapshot) Descendants added in v0.17.6 

func (s Snapshot) Descendants() ([]flow.Identifier, error)

func (Snapshot) Encodable 

func (s Snapshot) Encodable() EncodableSnapshot

func (Snapshot) EpochPhase added in v0.37.1 

func (s Snapshot) EpochPhase() (flow.EpochPhase, error)

func (Snapshot) EpochProtocolState added in v0.33.30 

func (s Snapshot) EpochProtocolState() (protocol.EpochProtocolState, error)

func (Snapshot) Epochs 

func (s Snapshot) Epochs() protocol.EpochQuery

func (Snapshot) Head 

func (s Snapshot) Head() (*flow.Header, error)

func (Snapshot) Identities 

func (s Snapshot) Identities(selector flow.IdentityFilter[flow.Identity]) (flow.IdentityList, error)

func (Snapshot) Identity 

func (s Snapshot) Identity(nodeID flow.Identifier) (*flow.Identity, error)

func (Snapshot) Params added in v0.23.2 

func (s Snapshot) Params() protocol.GlobalParams

func (Snapshot) ProtocolState added in v0.33.30 

func (s Snapshot) ProtocolState() (protocol.KVStoreReader, error)

func (Snapshot) QuorumCertificate 

func (s Snapshot) QuorumCertificate() (*flow.QuorumCertificate, error)

func (Snapshot) RandomSource added in v0.25.0 

func (s Snapshot) RandomSource() ([]byte, error)

func (Snapshot) SealedResult 

func (s Snapshot) SealedResult() (*flow.ExecutionResult, *flow.Seal, error)

func (Snapshot) SealingSegment 

func (s Snapshot) SealingSegment() (*flow.SealingSegment, error)

func (Snapshot) VersionBeacon added in v0.31.0 

func (s Snapshot) VersionBeacon() (*flow.SealedVersionBeacon, error)

Source Files

View all Source files

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.