inmem

package
v0.43.1-rc.1.access-me... Latest Latest
Warning

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

 Go to latest Published: Sep 30, 2025 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)

ClusteringFromSetupEvent generates a new clustering list from Epoch setup data. No errors expected during normal operation.

func EpochProtocolStateFromServiceEvents added in v0.33.30 

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

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, commitEvent *flow.EpochCommit, extensions []flow.EpochExtension) protocol.CommittedEpoch

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

func NewDKG added in v0.33.30 

func NewDKG(setup *flow.EpochSetup, commit *flow.EpochCommit) protocol.DKG

NewDKG creates a new DKG instance from the given setup and commit events.

func NewEpochWithEndBoundary added in v0.33.30 

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

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, commitEvent *flow.EpochCommit, extensions []flow.EpochExtension, firstHeight, finalHeight uint64) protocol.CommittedEpoch

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, commitEvent *flow.EpochCommit, extensions []flow.EpochExtension, firstHeight uint64) protocol.CommittedEpoch

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) protocol.TentativeEpoch

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 flow.EpochCommit

DKG defines a new type using flow.EpochCommit as underlying type and implements the protocol.DKG interface.

func (*DKG) GroupKey 

func (d *DKG) GroupKey() crypto.PublicKey

func (*DKG) Index 

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

Index returns the DKG index for the given node. Expected error during normal operations:

  • protocol.IdentityNotFoundError if nodeID is not a known 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. Expected error during normal operations:

  • protocol.IdentityNotFoundError if nodeID is not a known DKG participant

func (*DKG) KeyShares added in v0.39.0 

func (d *DKG) KeyShares() []crypto.PublicKey

KeyShares returns the public portions of all threshold key shares. Note that there might not exist a private key corresponding to each entry (e.g. if the respective node failed the DKG).

func (*DKG) NodeID added in v0.39.0 

func (d *DKG) NodeID(index uint) (flow.Identifier, error)

NodeID returns the node identifier for the given index. An exception is returned if the index is ≥ Size(). Intended for use outside the hotpath, with runtime scaling linearly in the number of DKG participants (ie. Size())

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 EncodableParams added in v0.23.2 

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

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
	Params protocol.GlobalParams
}

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

func NewEpochProtocolStateAdapter added in v0.33.30 

func NewEpochProtocolStateAdapter(untrusted UntrustedEpochProtocolStateAdapter) (*EpochProtocolStateAdapter, error)

NewEpochProtocolStateAdapter creates a new instance of EpochProtocolStateAdapter. Construction EpochProtocolStateAdapter allowed only within the constructor.

All errors indicate a valid EpochProtocolStateAdapter cannot be constructed from the input.

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 is a wrapper around flow.RichEpochStateEntry implementing the protocol.EpochQuery interface. It is intended for bootstrapping nodes. For ease of transferring the bootstrapping data from node to node, Epochs is backed by easily serializable data and does not have access to a proper protocol-data-base that would be part of a staked node. Therefore, it can _not_ return values for the `FirstHeight()` and `FinalHeight()` methods, which are part of the protocol.CommittedEpoch API. CAUTION: use [badger.Snapshot] for protocol logic except when bootstrapping a node.

func (Epochs) Current 

func (eq Epochs) Current() (protocol.CommittedEpoch, error)

Current returns the current epoch as of this snapshot. All valid snapshots have a current epoch.

func (Epochs) NextCommitted added in v0.39.2 

func (eq Epochs) NextCommitted() (protocol.CommittedEpoch, error)

NextCommitted returns the next epoch as of this snapshot, only if it has been committed already - generally that is the case only after an `EpochCommittedPhaseStarted` notification has been emitted.

Error returns:

  • [ErrNextEpochNotCommitted] - in the case that committed epoch has been requested w.r.t a snapshot within the flow.EpochPhaseStaking or flow.EpochPhaseSetup phases.
  • generic error in case of unexpected critical internal corruption or bugs

func (Epochs) NextUnsafe added in v0.39.2 

func (eq Epochs) NextUnsafe() (protocol.TentativeEpoch, error)

NextUnsafe should only be used by components that are actively involved in advancing the epoch from flow.EpochPhaseSetup to flow.EpochPhaseCommitted. NextUnsafe returns the tentative configuration for the next epoch as of this snapshot. Valid snapshots make such configuration available during the Epoch Setup Phase, which generally is the case only after an `EpochSetupPhaseStarted` notification has been emitted. CAUTION: epoch transition might not happen as described by the tentative configuration!

Error returns:

  • [ErrNextEpochNotSetup] in the case that this method is queried w.r.t. a snapshot within the flow.EpochPhaseStaking phase or when we are in Epoch Fallback Mode.
  • [ErrNextEpochAlreadyCommitted] if the tentative epoch is requested from a snapshot within the flow.EpochPhaseCommitted phase.
  • generic error in case of unexpected critical internal corruption or bugs

func (Epochs) Previous 

func (eq Epochs) Previous() (protocol.CommittedEpoch, error)

Previous returns the previous epoch as of this snapshot. Valid snapshots must have a previous epoch for all epochs except that immediately after the root block. Error returns:

  • protocol.ErrNoPreviousEpoch - if the previous epoch does not exist. This happens when the previous epoch is queried within the first epoch of a spork.

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) 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

func (Params) SporkRootBlockView added in v0.43.0 

func (p Params) SporkRootBlockView() 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 SnapshotFromBootstrapStateWithParams added in v0.29.0 

func SnapshotFromBootstrapStateWithParams(
	root *flow.Block,
	result *flow.ExecutionResult,
	seal *flow.Seal,
	qc *flow.QuorumCertificate,
	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)

type ThresholdKeySet added in v0.39.0 

type ThresholdKeySet struct {
	GroupKey     encodable.RandomBeaconPubKey
	Participants []ThresholdParticipant
}

ThresholdKeySet contains the key set for a threshold signature scheme. Typically, the ThresholdKeySet is used to encode the output of a trusted setup. In general, signature scheme is configured with a threshold parameter t, which is the number of malicious colluding nodes the signature scheme is safe against. To balance liveness and safety, the Flow protocol fixes threshold to t = floor((n-1)/2), for n the number of parties in the threshold cryptography scheme, specifically n = len(Participants). Without loss of generality, our threshold cryptography protocol with n parties identifies the individual participants by the indices {0, 1, …, n-1}. The slice Participants is ordered accordingly.

type ThresholdParticipant added in v0.39.0 

type ThresholdParticipant struct {
	PrivKeyShare encodable.RandomBeaconPrivKey
	PubKeyShare  encodable.RandomBeaconPubKey
	NodeID       flow.Identifier
}

ThresholdParticipant encodes the threshold key data for single participant.

type UntrustedEpochProtocolStateAdapter added in v0.43.0 

type UntrustedEpochProtocolStateAdapter EpochProtocolStateAdapter

UntrustedEpochProtocolStateAdapter is an untrusted input-only representation of a EpochProtocolStateAdapter, used for construction.

This type exists to ensure that constructor functions are invoked explicitly with named fields, which improves clarity and reduces the risk of incorrect field ordering during construction.

An instance of UntrustedEpochProtocolStateAdapter should be validated and converted into a trusted EpochProtocolStateAdapter using NewEpochProtocolStateAdapter constructor.

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.