inmem

package
v0.34.0-crescendo-prev... Latest Latest
Warning

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

 Go to latest Published: Feb 22, 2024 License: AGPL-3.0 Imports: 13 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 NewCommittedEpoch 

func NewCommittedEpoch(setupEvent *flow.EpochSetup, 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 NewEndedEpoch added in v0.30.0 

func NewEndedEpoch(setupEvent *flow.EpochSetup, commitEvent *flow.EpochCommit, firstHeight, finalHeight uint64) protocol.Epoch

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

func NewSetupEpoch 

func NewSetupEpoch(setupEvent *flow.EpochSetup) 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.

func NewStartedEpoch added in v0.30.0 

func NewStartedEpoch(setupEvent *flow.EpochSetup, commitEvent *flow.EpochCommit, firstHeight uint64) protocol.Epoch

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

func ProtocolStateFromEpochServiceEvents added in v0.35.4 

func ProtocolStateFromEpochServiceEvents(setup *flow.EpochSetup, commit *flow.EpochCommit) *flow.ProtocolStateEntry

ProtocolStateFromEpochServiceEvents generates a protocol.ProtocolStateEntry 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.

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 FromCluster 

func FromCluster(from protocol.Cluster) (*Cluster, error)

FromCluster converts any protocol.Cluster to a memory-backed Cluster. No errors are expected during normal operation.

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
}

func DKGFromEncodable 

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

DKGFromEncodable returns a DKG backed by the given encodable representation.

func FromDKG 

func FromDKG(from protocol.DKG, participants flow.IdentitySkeletonList) (*DKG, error)

FromDKG converts any protocol.DKG to a memory-backed DKG.

The given participant list must exactly match the DKG members. All errors indicate inconsistent or invalid inputs. No errors are expected during normal operation.

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 DynamicProtocolStateAdapter added in v0.35.4 

type DynamicProtocolStateAdapter struct {
	InitialProtocolStateAdapter
	// contains filtered or unexported fields
}

DynamicProtocolStateAdapter implements protocol.DynamicProtocolState by wrapping an InitialProtocolStateAdapter.

func NewDynamicProtocolStateAdapter added in v0.35.4 

func NewDynamicProtocolStateAdapter(entry *flow.RichProtocolStateEntry, params protocol.GlobalParams) *DynamicProtocolStateAdapter

func (*DynamicProtocolStateAdapter) EpochPhase added in v0.35.4 

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

EpochPhase returns the epoch phase for the current epoch.

func (*DynamicProtocolStateAdapter) GlobalParams added in v0.35.4 

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

func (*DynamicProtocolStateAdapter) Identities added in v0.35.4 

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

func (*DynamicProtocolStateAdapter) InvalidEpochTransitionAttempted added in v0.35.4 

func (s *DynamicProtocolStateAdapter) InvalidEpochTransitionAttempted() bool

InvalidEpochTransitionAttempted 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 (*DynamicProtocolStateAdapter) PreviousEpochExists added in v0.35.4 

func (s *DynamicProtocolStateAdapter) PreviousEpochExists() bool

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

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 EncodableEpoch 

type EncodableEpoch struct {
	Counter            uint64
	FirstView          uint64
	DKGPhase1FinalView uint64
	DKGPhase2FinalView uint64
	DKGPhase3FinalView uint64
	FinalView          uint64
	RandomSource       []byte
	TargetDuration     uint64 // desired real-world duration for the epoch, in seconds
	TargetEndTime      uint64 // desired real-world end time for the epoch, in UNIX time [seconds]
	InitialIdentities  flow.IdentitySkeletonList
	Clustering         flow.ClusterList
	Clusters           []EncodableCluster
	DKG                *EncodableDKG
	FirstHeight        *uint64
	FinalHeight        *uint64
}

EncodableEpoch is the encoding format for protocol.Epoch

type EncodableEpochs 

type EncodableEpochs struct {
	Previous *EncodableEpoch
	Current  EncodableEpoch // cannot be nil
	Next     *EncodableEpoch
}

EncodableEpochs is the encoding format for protocol.EpochQuery

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
	EpochCommitSafetyThreshold uint64
}

EncodableParams is the encoding format for protocol.GlobalParams

type EncodableSnapshot 

type EncodableSnapshot struct {
	Head                *flow.Header
	LatestSeal          *flow.Seal
	LatestResult        *flow.ExecutionResult
	SealingSegment      *flow.SealingSegment
	QuorumCertificate   *flow.QuorumCertificate
	Epochs              EncodableEpochs
	Params              EncodableParams
	ProtocolState       *flow.ProtocolStateEntry
	SealedVersionBeacon *flow.SealedVersionBeacon
}

EncodableSnapshot is the encoding format for protocol.Snapshot

type Epoch 

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

Epoch is a memory-backed implementation of protocol.Epoch.

func FromEpoch 

func FromEpoch(from protocol.Epoch) (*Epoch, error)

FromEpoch converts any protocol.Epoch to a memory-backed Epoch. Error returns: * protocol.ErrNoPreviousEpoch - if the epoch represents a previous epoch which does not exist. * protocol.ErrNextEpochNotSetup - if the epoch represents a next epoch which has not been set up. * state.ErrUnknownSnapshotReference - if the epoch is queried from an unresolvable snapshot.

func NewEpoch 

func NewEpoch(enc EncodableEpoch) Epoch

func (Epoch) Cluster 

func (e Epoch) Cluster(i uint) (protocol.Cluster, error)

func (Epoch) ClusterByChainID added in v0.26.1 

func (e Epoch) ClusterByChainID(chainID flow.ChainID) (protocol.Cluster, error)

func (Epoch) Clustering 

func (e Epoch) Clustering() (flow.ClusterList, error)

func (Epoch) Counter 

func (e Epoch) Counter() (uint64, error)

func (Epoch) DKG 

func (e Epoch) DKG() (protocol.DKG, error)

func (Epoch) DKGPhase1FinalView added in v0.20.0 

func (e Epoch) DKGPhase1FinalView() (uint64, error)

func (Epoch) DKGPhase2FinalView added in v0.20.0 

func (e Epoch) DKGPhase2FinalView() (uint64, error)

func (Epoch) DKGPhase3FinalView added in v0.20.0 

func (e Epoch) DKGPhase3FinalView() (uint64, error)

func (Epoch) Encodable added in v0.20.0 

func (e Epoch) Encodable() EncodableEpoch

func (Epoch) FinalHeight added in v0.30.0 

func (e Epoch) FinalHeight() (uint64, error)

func (Epoch) FinalView 

func (e Epoch) FinalView() (uint64, error)

func (Epoch) FirstHeight added in v0.30.0 

func (e Epoch) FirstHeight() (uint64, error)

func (Epoch) FirstView 

func (e Epoch) FirstView() (uint64, error)

func (Epoch) InitialIdentities 

func (e Epoch) InitialIdentities() (flow.IdentitySkeletonList, error)

func (Epoch) RandomSource 

func (e Epoch) RandomSource() ([]byte, error)

func (Epoch) TargetDuration 

func (e Epoch) TargetDuration() (uint64, error)

TargetDuration returns the desired real-world duration for this epoch, in seconds. This target is specified by the FlowEpoch smart contract in the EpochSetup event and used by the Cruise Control system to moderate the block rate.

func (Epoch) TargetEndTime 

func (e Epoch) TargetEndTime() (uint64, error)

TargetEndTime returns the desired real-world end time for this epoch, represented as Unix Time (in units of seconds). This target is specified by the FlowEpoch smart contract in the EpochSetup event and used by the Cruise Control system to moderate the block rate.

type Epochs 

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

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 InitialProtocolStateAdapter added in v0.35.4 

type InitialProtocolStateAdapter struct {
	*flow.RichProtocolStateEntry
}

InitialProtocolStateAdapter implements protocol.InitialProtocolState by wrapping a RichProtocolStateEntry. TODO(yuraolex): for sake of avoiding errors in return values in interface methods this adapter pre-caches some values. This is debatable as clustering for instance is not accessed frequently and could be lazily loaded. The problem with lazy loading is handling error value from `inmem.ClusteringFromSetupEvent`. There are two ways to avoid it: 1. Return error from interface method. 2. Inject irrecoverable.Signaler into the adapter and panic on error since any error in that method has to be a severe implementation bug.

func NewInitialProtocolStateAdapter added in v0.35.4 

func NewInitialProtocolStateAdapter(entry *flow.RichProtocolStateEntry) *InitialProtocolStateAdapter

func (*InitialProtocolStateAdapter) Clustering added in v0.35.4 

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

func (*InitialProtocolStateAdapter) DKG added in v0.35.4 

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

func (*InitialProtocolStateAdapter) Entry added in v0.35.4 

func (s *InitialProtocolStateAdapter) Entry() *flow.RichProtocolStateEntry

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 (*InitialProtocolStateAdapter) Epoch added in v0.35.4 

func (s *InitialProtocolStateAdapter) Epoch() uint64

func (*InitialProtocolStateAdapter) EpochCommit added in v0.35.4 

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

func (*InitialProtocolStateAdapter) EpochSetup added in v0.35.4 

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

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) EpochCommitSafetyThreshold added in v0.29.0 

func (p Params) EpochCommitSafetyThreshold() uint64

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,
	epochCommitSafetyThreshold uint64,
) (*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) 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) Phase 

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

func (Snapshot) ProtocolState added in v0.33.30 

func (s Snapshot) ProtocolState() (protocol.DynamicProtocolState, 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.