store

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: 17 Imported by: 1

Documentation

Index

Constants

View Source 
const DefaultCacheSize = uint(1000)
View Source 
const DefaultChunkQueuesCacheSize = uint(1000)
View Source 
const JobQueueChunksQueue = "JobQueueChunksQueue"

Variables

View Source 
var DefaultEpochProtocolStateCacheSize uint = 20

DefaultEpochProtocolStateCacheSize is the default size for primary epoch protocol state entry cache. Minimally, we have 3 entries per epoch (one on epoch Switchover, one on receiving the Epoch Setup and one when seeing the Epoch Commit event). Let's be generous and assume we have 20 different epoch state entries per epoch.

View Source 
var DefaultProtocolKVStoreByBlockIDCacheSize uint = 1000

DefaultProtocolKVStoreByBlockIDCacheSize is the default value for secondary index `byBlockIdCache`. We want to be able to cover a broad interval of views without cache misses, so we use a bigger value. Generally, many blocks will reference the same KV store snapshot.

View Source 
var DefaultProtocolKVStoreCacheSize uint = 10

DefaultProtocolKVStoreCacheSize is the default size for primary protocol KV store cache. KV store is rarely updated, so we will have a limited number of unique snapshots. Let's be generous and assume we have 10 different KV stores used at the same time.

View Source 
var DefaultProtocolStateIndexCacheSize uint = 1000

DefaultProtocolStateIndexCacheSize is the default value for secondary byBlockIdCache. We want to be able to cover a broad interval of views without cache misses, so we use a bigger value.

Functions

func KeyToBlockIDIndex added in v0.39.4 

func KeyToBlockIDIndex(key IdentifierAndUint32) (flow.Identifier, uint32)

func KeyToBlockIDTransactionID added in v0.39.4 

func KeyToBlockIDTransactionID(key TwoIdentifier) (flow.Identifier, flow.Identifier)

Types

type All added in v0.43.0 

type All struct {
	Headers            *Headers
	Guarantees         *Guarantees
	Seals              *Seals
	Index              *Index
	Payloads           *Payloads
	Blocks             *Blocks
	QuorumCertificates *QuorumCertificates
	Results            *ExecutionResults
	Receipts           *ExecutionReceipts
	Commits            *Commits

	EpochSetups               *EpochSetups
	EpochCommits              *EpochCommits
	EpochProtocolStateEntries *EpochProtocolStateEntries
	ProtocolKVStore           *ProtocolKVStore
	VersionBeacons            *VersionBeacons

	Transactions *Transactions
	Collections  *Collections
}

func InitAll added in v0.43.0 

func InitAll(metrics module.CacheMetrics, db storage.DB) *All

type Blocks added in v0.43.0 

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

Blocks implements a simple block storage around a badger DB.

func NewBlocks added in v0.43.0 

func NewBlocks(db storage.DB, headers *Headers, payloads *Payloads) *Blocks

NewBlocks ...

func (*Blocks) BatchStore added in v0.43.0 

func (b *Blocks) BatchStore(lctx lockctx.Proof, rw storage.ReaderBatchWriter, proposal *flow.Proposal) error

BatchStore stores a valid block in a batch.

Expected errors during normal operations: - storage.ErrAlreadyExists if some block with the same ID has already been stored

func (*Blocks) ByCollectionID added in v0.43.0 

func (b *Blocks) ByCollectionID(collID flow.Identifier) (*flow.Block, error)

ByCollectionID returns the block for the given flow.CollectionGuarantee ID. This method is only available for collections included in finalized blocks. While consensus nodes verify that collections are not repeated within the same fork, each different fork can contain a recent collection once. Therefore, we must wait for finality. CAUTION: this method is not backed by a cache and therefore comparatively slow!

Error returns:

  • storage.ErrNotFound if the collection ID was not found
  • generic error in case of unexpected failure from the database layer, or failure to decode an existing database value

func (*Blocks) ByHeight added in v0.43.0 

func (b *Blocks) ByHeight(height uint64) (*flow.Block, error)

ByHeight returns the block at the given height. It is only available for finalized blocks.

Error returns:

  • storage.ErrNotFound if no block for the corresponding height was found
  • generic error in case of unexpected failure from the database layer, or failure to decode an existing database value

func (*Blocks) ByID added in v0.43.0 

func (b *Blocks) ByID(blockID flow.Identifier) (*flow.Block, error)

ByID returns the block with the given hash. It is available for all incorporated blocks (validated blocks that have been appended to any of the known forks) no matter whether the block has been finalized or not.

Error returns:

  • storage.ErrNotFound if no block with the corresponding ID was found
  • generic error in case of unexpected failure from the database layer, or failure to decode an existing database value

func (*Blocks) ByView added in v0.43.0 

func (b *Blocks) ByView(view uint64) (*flow.Block, error)

ByView returns the block with the given view. It is only available for certified blocks. certified blocks are the blocks that have received QC. Hotstuff guarantees that for each view, at most one block is certified. Hence, the return value of `ByView` is guaranteed to be unique even for non-finalized blocks. Expected errors during normal operations:

  • `storage.ErrNotFound` if no certified block is known at given view.

func (*Blocks) IndexBlockContainingCollectionGuarantees added in v0.43.0 

func (b *Blocks) IndexBlockContainingCollectionGuarantees(blockID flow.Identifier, guaranteeIDs []flow.Identifier) error

IndexBlockContainingCollectionGuarantees populates an index `guaranteeID->blockID` for each guarantee which appears in the block. CAUTION: a collection can be included in multiple *unfinalized* blocks. However, the implementation assumes a one-to-one map from collection ID to a *single* block ID. This holds for FINALIZED BLOCKS ONLY *and* only in the absence of byzantine collector clusters (which the mature protocol must tolerate). Hence, this function should be treated as a temporary solution, which requires generalization (one-to-many mapping) for soft finality and the mature protocol.

Error returns:

  • generic error in case of unexpected failure from the database layer or encoding failure.

func (*Blocks) ProposalByHeight added in v0.43.0 

func (b *Blocks) ProposalByHeight(height uint64) (*flow.Proposal, error)

ProposalByHeight returns the block at the given height, along with the proposer's signature on it. It is only available for finalized blocks.

Error returns:

  • storage.ErrNotFound if no block proposal for the corresponding height was found
  • generic error in case of unexpected failure from the database layer, or failure to decode an existing database value

func (*Blocks) ProposalByID added in v0.43.0 

func (b *Blocks) ProposalByID(blockID flow.Identifier) (*flow.Proposal, error)

ProposalByID returns the block with the given ID, along with the proposer's signature on it. It is available for all incorporated blocks (validated blocks that have been appended to any of the known forks) no matter whether the block has been finalized or not.

Error returns:

  • storage.ErrNotFound if no block with the corresponding ID was found
  • generic error in case of unexpected failure from the database layer, or failure to decode an existing database value

func (*Blocks) ProposalByView added in v0.43.0 

func (b *Blocks) ProposalByView(view uint64) (*flow.Proposal, error)

ProposalByView returns the block proposal with the given view. It is only available for certified blocks.

Expected errors during normal operations:

  • `storage.ErrNotFound` if no certified block is known at given view.

type Cache 

type Cache[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func (*Cache[K, V]) Get 

func (c *Cache[K, V]) Get(r storage.Reader, key K) (V, error)

Get will try to retrieve the resource from cache first, and then from the injected. During normal operations, the following error returns are expected:

  • `storage.ErrNotFound` if key is unknown.

func (*Cache[K, V]) Insert 

func (c *Cache[K, V]) Insert(key K, resource V)

Insert will add a resource directly to the cache with the given ID

func (*Cache[K, V]) IsCached 

func (c *Cache[K, V]) IsCached(key K) bool

IsCached returns true if the key exists in the cache. It DOES NOT check whether the key exists in the underlying data store.

func (*Cache[K, V]) PutTx 

func (c *Cache[K, V]) PutTx(rw storage.ReaderBatchWriter, key K, resource V) error

PutTx will return tx which adds a resource to the cache with the given ID.

func (*Cache[K, V]) PutWithLockTx added in v0.43.0 

func (c *Cache[K, V]) PutWithLockTx(lctx lockctx.Proof, rw storage.ReaderBatchWriter, key K, resource V) error

func (*Cache[K, V]) Remove 

func (c *Cache[K, V]) Remove(key K)

func (*Cache[K, V]) RemoveTx added in v0.41.0 

func (c *Cache[K, V]) RemoveTx(rw storage.ReaderBatchWriter, key K) error

type ChunkDataPacks 

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

func NewChunkDataPacks 

func NewChunkDataPacks(collector module.CacheMetrics, db storage.DB, collections storage.Collections, byChunkIDCacheSize uint) *ChunkDataPacks

func (*ChunkDataPacks) BatchRemove 

func (ch *ChunkDataPacks) BatchRemove(chunkID flow.Identifier, rw storage.ReaderBatchWriter) error

BatchRemove removes ChunkDataPack c keyed by its ChunkID in provided batch No errors are expected during normal operation, even if no entries are matched. If Badger unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*ChunkDataPacks) BatchStore 

func (ch *ChunkDataPacks) BatchStore(c *flow.ChunkDataPack, rw storage.ReaderBatchWriter) error

BatchStore stores ChunkDataPack c keyed by its ChunkID in provided batch. No errors are expected during normal operation, but it may return generic error if entity is not serializable or Badger unexpectedly fails to process request

func (*ChunkDataPacks) ByChunkID 

func (ch *ChunkDataPacks) ByChunkID(chunkID flow.Identifier) (*flow.ChunkDataPack, error)

func (*ChunkDataPacks) Remove 

func (ch *ChunkDataPacks) Remove(chunkIDs []flow.Identifier) error

Remove removes multiple ChunkDataPacks cs keyed by their ChunkIDs in a batch. No errors are expected during normal operation, even if no entries are matched.

func (*ChunkDataPacks) Store 

func (ch *ChunkDataPacks) Store(cs []*flow.ChunkDataPack) error

Store stores multiple ChunkDataPacks cs keyed by their ChunkIDs in a batch. No errors are expected during normal operation, but it may return generic error

type ChunksQueue added in v0.39.1 

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

ChunksQueue stores a queue of chunk locators that assigned to me to verify. Job consumers can read the locators as job from the queue by index. Chunk locators stored in this queue are unique.

func NewChunkQueue added in v0.39.1 

func NewChunkQueue(collector module.CacheMetrics, db storage.DB) *ChunksQueue

NewChunkQueue will initialize the underlying badger database of chunk locator queue.

func (*ChunksQueue) AtIndex added in v0.39.1 

func (q *ChunksQueue) AtIndex(index uint64) (*chunks.Locator, error)

AtIndex returns the chunk locator stored at the given index in the queue.

func (*ChunksQueue) Init added in v0.39.1 

func (q *ChunksQueue) Init(defaultIndex uint64) (bool, error)

Init initializes chunk queue's latest index with the given default index. It returns (false, nil) if the chunk queue is already initialized. It returns (true, nil) if the chunk queue is successfully initialized.

func (*ChunksQueue) LatestIndex added in v0.39.1 

func (q *ChunksQueue) LatestIndex() (uint64, error)

LatestIndex returns the index of the latest chunk locator stored in the queue.

func (*ChunksQueue) StoreChunkLocator added in v0.39.1 

func (q *ChunksQueue) StoreChunkLocator(locator *chunks.Locator) (bool, error)

StoreChunkLocator stores a new chunk locator that assigned to me to the job queue. A true will be returned, if the locator was new. A false will be returned, if the locator was duplicate.

type ClusterBlocks added in v0.43.0 

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

ClusterBlocks implements a simple block storage around a badger DB.

func NewClusterBlocks added in v0.43.0 

func NewClusterBlocks(db storage.DB, chainID flow.ChainID, headers *Headers, payloads *ClusterPayloads) *ClusterBlocks

func (*ClusterBlocks) ProposalByHeight added in v0.43.0 

func (b *ClusterBlocks) ProposalByHeight(height uint64) (*cluster.Proposal, error)

func (*ClusterBlocks) ProposalByID added in v0.43.0 

func (b *ClusterBlocks) ProposalByID(blockID flow.Identifier) (*cluster.Proposal, error)

type ClusterPayloads added in v0.43.0 

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

ClusterPayloads implements storage of block payloads for collection node cluster consensus.

func NewClusterPayloads added in v0.43.0 

func NewClusterPayloads(cacheMetrics module.CacheMetrics, db storage.DB) *ClusterPayloads

func (*ClusterPayloads) ByBlockID added in v0.43.0 

func (cp *ClusterPayloads) ByBlockID(blockID flow.Identifier) (*cluster.Payload, error)

type Collections added in v0.39.4 

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

func NewCollections added in v0.39.4 

func NewCollections(db storage.DB, transactions *Transactions) *Collections

func (*Collections) BatchStoreAndIndexByTransaction added in v0.43.0 

func (c *Collections) BatchStoreAndIndexByTransaction(lctx lockctx.Proof, collection *flow.Collection, rw storage.ReaderBatchWriter) (*flow.LightCollection, error)

BatchStoreAndIndexByTransaction stores a collection and indexes it by transaction ID within a batch.

CAUTION: current approach is NOT BFT and needs to be revised in the future. Honest clusters ensure a transaction can only belong to one collection. However, in rare cases, the collector clusters can exceed byzantine thresholds -- making it possible to produce multiple finalized collections (aka guaranteed collections) containing the same transaction repeatedly. TODO: eventually we need to handle Byzantine clusters

No errors are expected during normal operations

func (*Collections) ByID added in v0.39.4 

func (c *Collections) ByID(colID flow.Identifier) (*flow.Collection, error)

ByID returns the collection with the given ID, including all transactions within the collection.

Expected errors during normal operation:

  • `storage.ErrNotFound` if no light collection was found.

func (*Collections) LightByID added in v0.39.4 

func (c *Collections) LightByID(colID flow.Identifier) (*flow.LightCollection, error)

LightByID returns a reduced representation of the collection with the given ID. The reduced collection references the constituent transactions by their hashes.

Expected errors during normal operation:

  • `storage.ErrNotFound` if no light collection was found.

func (*Collections) LightByTransactionID added in v0.39.4 

func (c *Collections) LightByTransactionID(txID flow.Identifier) (*flow.LightCollection, error)

LightByTransactionID returns a reduced representation of the collection holding the given transaction ID. The reduced collection references the constituent transactions by their hashes.

Expected errors during normal operation:

  • `storage.ErrNotFound` if no light collection was found.

func (*Collections) Remove added in v0.39.4 

func (c *Collections) Remove(colID flow.Identifier) error

Remove removes a collection from the database, including all constituent transactions and indices inserted by Store. Remove does not error if the collection does not exist Note: this method should only be called for collections included in blocks below sealed height No errors are expected during normal operation.

func (*Collections) Store added in v0.39.4 

func (c *Collections) Store(collection *flow.Collection) (*flow.LightCollection, error)

Store stores a collection in the database. any error returned are exceptions

func (*Collections) StoreAndIndexByTransaction added in v0.43.0 

func (c *Collections) StoreAndIndexByTransaction(lctx lockctx.Proof, collection *flow.Collection) (*flow.LightCollection, error)

StoreAndIndexByTransaction stores a collection and indexes it by transaction ID. It's concurrent-safe.

CAUTION: current approach is NOT BFT and needs to be revised in the future. Honest clusters ensure a transaction can only belong to one collection. However, in rare cases, the collector clusters can exceed byzantine thresholds -- making it possible to produce multiple finalized collections (aka guaranteed collections) containing the same transaction repeatedly. TODO: eventually we need to handle Byzantine clusters

No errors are expected during normal operation.

type Commits added in v0.39.4 

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

func NewCommits added in v0.39.4 

func NewCommits(collector module.CacheMetrics, db storage.DB) *Commits

func (*Commits) BatchRemoveByBlockID added in v0.39.4 

func (c *Commits) BatchRemoveByBlockID(blockID flow.Identifier, rw storage.ReaderBatchWriter) error

BatchRemoveByBlockID removes Commit keyed by blockID in provided batch No errors are expected during normal operation, even if no entries are matched. If the database unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*Commits) BatchStore added in v0.39.4 

func (c *Commits) BatchStore(lctx lockctx.Proof, blockID flow.Identifier, commit flow.StateCommitment, rw storage.ReaderBatchWriter) error

BatchStore stores Commit keyed by blockID in provided batch No errors are expected during normal operation. If the database unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*Commits) ByBlockID added in v0.39.4 

func (c *Commits) ByBlockID(blockID flow.Identifier) (flow.StateCommitment, error)

func (*Commits) RemoveByBlockID added in v0.39.4 

func (c *Commits) RemoveByBlockID(blockID flow.Identifier) error

type ComputationResultUploadStatus added in v0.39.2 

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

func NewComputationResultUploadStatus added in v0.39.2 

func NewComputationResultUploadStatus(db storage.DB) *ComputationResultUploadStatus

func (*ComputationResultUploadStatus) ByID added in v0.39.2 

func (c *ComputationResultUploadStatus) ByID(computationResultID flow.Identifier) (bool, error)

func (*ComputationResultUploadStatus) GetIDsByUploadStatus added in v0.39.2 

func (c *ComputationResultUploadStatus) GetIDsByUploadStatus(targetUploadStatus bool) ([]flow.Identifier, error)

func (*ComputationResultUploadStatus) Remove added in v0.39.2 

func (c *ComputationResultUploadStatus) Remove(computationResultID flow.Identifier) error

func (*ComputationResultUploadStatus) Upsert added in v0.39.2 

func (c *ComputationResultUploadStatus) Upsert(blockID flow.Identifier,
	wasUploadCompleted bool) error

type ConsumerProgressInitializer 

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

ConsumerProgressInitializer is a helper to initialize the consumer progress index in storage It prevents the consumer from being used before initialization

func NewConsumerProgress 

func NewConsumerProgress(db storage.DB, consumer string) *ConsumerProgressInitializer

func (*ConsumerProgressInitializer) Initialize 

func (cpi *ConsumerProgressInitializer) Initialize(defaultIndex uint64) (storage.ConsumerProgress, error)

type EpochCommits added in v0.43.0 

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

func NewEpochCommits added in v0.43.0 

func NewEpochCommits(collector module.CacheMetrics, db storage.DB) *EpochCommits

func (*EpochCommits) BatchStore added in v0.43.0 

func (ec *EpochCommits) BatchStore(rw storage.ReaderBatchWriter, commit *flow.EpochCommit) error

func (*EpochCommits) ByID added in v0.43.0 

func (ec *EpochCommits) ByID(commitID flow.Identifier) (*flow.EpochCommit, error)

ByID will return the EpochCommit event by its ID. Error returns: * storage.ErrNotFound if no EpochCommit with the ID exists

type EpochProtocolStateEntries added in v0.43.0 

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

EpochProtocolStateEntries implements a persistent, fork-aware storage for the Epoch-related sub-states of the overall of the overall Protocol State (KV Store). It uses an embedded cache which is populated on first retrieval to speed up access to frequently used epoch sub-state.

func NewEpochProtocolStateEntries added in v0.43.0 

func NewEpochProtocolStateEntries(collector module.CacheMetrics,
	epochSetups storage.EpochSetups,
	epochCommits storage.EpochCommits,
	db storage.DB,
	stateCacheSize uint,
	stateByBlockIDCacheSize uint,
) *EpochProtocolStateEntries

NewEpochProtocolStateEntries creates a EpochProtocolStateEntries instance, which stores a subset of the state stored by the Dynamic Protocol State. It supports storing, caching and retrieving by ID or the additionally indexed block ID.

func (*EpochProtocolStateEntries) BatchIndex added in v0.43.0 

func (s *EpochProtocolStateEntries) BatchIndex(rw storage.ReaderBatchWriter, blockID flow.Identifier, epochProtocolStateEntryID flow.Identifier) error

BatchIndex persists the specific map entry in the node's database. In a nutshell, we want to maintain a map from `blockID` to `epochStateEntry`, where `blockID` references the block that _proposes_ the referenced epoch protocol state entry. Protocol convention:

  • Consider block B, whose ingestion might potentially lead to an updated protocol state. For example, the protocol state changes if we seal some execution results emitting service events.
  • For the key `blockID`, we use the identity of block B which _proposes_ this Protocol State. As value, the hash of the resulting protocol state at the end of processing B is to be used.
  • CAUTION: The protocol state requires confirmation by a QC and will only become active at the child block, _after_ validating the QC.

No errors are expected during normal operation.

func (*EpochProtocolStateEntries) BatchStore added in v0.43.0 

func (s *EpochProtocolStateEntries) BatchStore(
	w storage.Writer,
	epochProtocolStateEntryID flow.Identifier,
	epochStateEntry *flow.MinEpochStateEntry,
) error

BatchStore persists the given epoch protocol state entry as part of a DB batch. Per convention, the identities in the flow.MinEpochStateEntry must be in canonical order for the current and next epoch (if present), otherwise an exception is returned. No errors are expected during normal operation.

func (*EpochProtocolStateEntries) ByBlockID added in v0.43.0 

func (s *EpochProtocolStateEntries) ByBlockID(blockID flow.Identifier) (*flow.RichEpochStateEntry, error)

ByBlockID retrieves the epoch protocol state entry that the block with the given ID proposes. CAUTION: this protocol state requires confirmation by a QC and will only become active at the child block, _after_ validating the QC. Protocol convention:

  • Consider block B, whose ingestion might potentially lead to an updated protocol state. For example, the protocol state changes if we seal some execution results emitting service events.
  • For the key `blockID`, we use the identity of block B which _proposes_ this Protocol State. As value, the hash of the resulting protocol state at the end of processing B is to be used.
  • CAUTION: The protocol state requires confirmation by a QC and will only become active at the child block, _after_ validating the QC.

Expected errors during normal operations:

  • storage.ErrNotFound if no state entry has been indexed for the given block.

func (*EpochProtocolStateEntries) ByID added in v0.43.0 

func (s *EpochProtocolStateEntries) ByID(epochProtocolStateEntryID flow.Identifier) (*flow.RichEpochStateEntry, error)

ByID returns the epoch protocol state entry by its ID. Expected errors during normal operations:

  • storage.ErrNotFound if no protocol state with the given Identifier is known.

type EpochSetups added in v0.43.0 

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

func NewEpochSetups added in v0.43.0 

func NewEpochSetups(collector module.CacheMetrics, db storage.DB) *EpochSetups

NewEpochSetups instantiates a new EpochSetups storage.

func (*EpochSetups) BatchStore added in v0.43.0 

func (es *EpochSetups) BatchStore(rw storage.ReaderBatchWriter, setup *flow.EpochSetup) error

No errors are expected during normal operation.

func (*EpochSetups) ByID added in v0.43.0 

func (es *EpochSetups) ByID(setupID flow.Identifier) (*flow.EpochSetup, error)

ByID will return the EpochSetup event by its ID. Error returns: * storage.ErrNotFound if no EpochSetup with the ID exists

type Events added in v0.39.4 

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

func NewEvents added in v0.39.4 

func NewEvents(collector module.CacheMetrics, db storage.DB) *Events

func (*Events) BatchRemoveByBlockID added in v0.39.4 

func (e *Events) BatchRemoveByBlockID(blockID flow.Identifier, rw storage.ReaderBatchWriter) error

BatchRemoveByBlockID removes events keyed by a blockID in provided batch No errors are expected during normal operation, even if no entries are matched. If Badger unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*Events) BatchStore added in v0.39.4 

func (e *Events) BatchStore(blockID flow.Identifier, blockEvents []flow.EventsList, batch storage.ReaderBatchWriter) error

BatchStore stores events keyed by a blockID in provided batch No errors are expected during normal operation, but it may return generic error if badger fails to process request

func (*Events) ByBlockID added in v0.39.4 

func (e *Events) ByBlockID(blockID flow.Identifier) ([]flow.Event, error)

ByBlockID returns the events for the given block ID Note: This method will return an empty slice and no error if no entries for the blockID are found

func (*Events) ByBlockIDEventType added in v0.39.4 

func (e *Events) ByBlockIDEventType(blockID flow.Identifier, eventType flow.EventType) ([]flow.Event, error)

ByBlockIDEventType returns the events for the given block ID and event type Note: This method will return an empty slice and no error if no entries for the blockID are found

func (*Events) ByBlockIDTransactionID added in v0.39.4 

func (e *Events) ByBlockIDTransactionID(blockID flow.Identifier, txID flow.Identifier) ([]flow.Event, error)

ByBlockIDTransactionID returns the events for the given block ID and transaction ID Note: This method will return an empty slice and no error if no entries for the blockID are found

func (*Events) ByBlockIDTransactionIndex added in v0.39.4 

func (e *Events) ByBlockIDTransactionIndex(blockID flow.Identifier, txIndex uint32) ([]flow.Event, error)

ByBlockIDTransactionIndex returns the events for the given block ID and transaction index Note: This method will return an empty slice and no error if no entries for the blockID are found

func (*Events) RemoveByBlockID added in v0.39.4 

func (e *Events) RemoveByBlockID(blockID flow.Identifier) error

RemoveByBlockID removes events by block ID

func (*Events) Store added in v0.39.4 

func (e *Events) Store(blockID flow.Identifier, blockEvents []flow.EventsList) error

Store will store events for the given block ID

type ExecutionForkEvidence added in v0.42.1 

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

ExecutionForkEvidence represents persistent storage for execution fork evidence.

func NewExecutionForkEvidence added in v0.42.1 

func NewExecutionForkEvidence(db storage.DB) *ExecutionForkEvidence

NewExecutionForkEvidence creates a new ExecutionForkEvidence store.

func (*ExecutionForkEvidence) Retrieve added in v0.42.1 

func (efe *ExecutionForkEvidence) Retrieve() ([]*flow.IncorporatedResultSeal, error)

Retrieve reads conflicting seals from the database. No error is returned if database record doesn't exist. No errors are expected during normal operations.

func (*ExecutionForkEvidence) StoreIfNotExists added in v0.42.1 

func (efe *ExecutionForkEvidence) StoreIfNotExists(conflictingSeals []*flow.IncorporatedResultSeal) error

StoreIfNotExists stores the given conflictingSeals to the database. This is a no-op if there is already a record in the database with the same key. No errors are expected during normal operations. CAUTION: This function is not safe for concurrent use by multiple goroutines. For safety, we rely on the fact that Execution Fork Evidence has a very small surface area of use in the Execution Fork Suppressor. The Execution Fork Suppressor is responsible for ensuring mutually exclusive access to this function.

type ExecutionReceipts added in v0.39.4 

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

ExecutionReceipts implements storage for execution receipts.

func NewExecutionReceipts added in v0.39.4 

func NewExecutionReceipts(collector module.CacheMetrics, db storage.DB, results storage.ExecutionResults, cacheSize uint) *ExecutionReceipts

NewExecutionReceipts Creates ExecutionReceipts instance which is a database of receipts which supports storing and indexing receipts by receipt ID and block ID.

func (*ExecutionReceipts) BatchStore added in v0.39.4 

func (r *ExecutionReceipts) BatchStore(receipt *flow.ExecutionReceipt, rw storage.ReaderBatchWriter) error

func (*ExecutionReceipts) ByBlockID added in v0.39.4 

func (r *ExecutionReceipts) ByBlockID(blockID flow.Identifier) (flow.ExecutionReceiptList, error)

ByBlockID retrieves list of execution receipts from the storage

No errors are expected errors during normal operations.

func (*ExecutionReceipts) ByID added in v0.39.4 

func (r *ExecutionReceipts) ByID(receiptID flow.Identifier) (*flow.ExecutionReceipt, error)

func (*ExecutionReceipts) Store added in v0.39.4 

func (r *ExecutionReceipts) Store(receipt *flow.ExecutionReceipt) error

type ExecutionResults added in v0.39.4 

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

ExecutionResults implements persistent storage for execution results.

func NewExecutionResults added in v0.39.4 

func NewExecutionResults(collector module.CacheMetrics, db storage.DB) *ExecutionResults

func (*ExecutionResults) BatchIndex added in v0.39.4 

func (r *ExecutionResults) BatchIndex(blockID flow.Identifier, resultID flow.Identifier, batch storage.ReaderBatchWriter) error

func (*ExecutionResults) BatchRemoveIndexByBlockID added in v0.39.4 

func (r *ExecutionResults) BatchRemoveIndexByBlockID(blockID flow.Identifier, batch storage.ReaderBatchWriter) error

BatchRemoveIndexByBlockID removes blockID-to-executionResultID index entries keyed by blockID in a provided batch. No errors are expected during normal operation, even if no entries are matched. If Badger unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*ExecutionResults) BatchStore added in v0.39.4 

func (r *ExecutionResults) BatchStore(result *flow.ExecutionResult, batch storage.ReaderBatchWriter) error

func (*ExecutionResults) ByBlockID added in v0.39.4 

func (r *ExecutionResults) ByBlockID(blockID flow.Identifier) (*flow.ExecutionResult, error)

func (*ExecutionResults) ByID added in v0.39.4 

func (r *ExecutionResults) ByID(resultID flow.Identifier) (*flow.ExecutionResult, error)

func (*ExecutionResults) ForceIndex added in v0.39.4 

func (r *ExecutionResults) ForceIndex(blockID flow.Identifier, resultID flow.Identifier) error

func (*ExecutionResults) Index added in v0.39.4 

func (r *ExecutionResults) Index(blockID flow.Identifier, resultID flow.Identifier) error

Index indexes an execution result by block ID. Note: this method call is not concurrent safe, because it checks if the different result is already indexed by the same blockID, and if it is, it returns an error. The caller needs to ensure that there is no concurrent call to this method with the same blockID.

func (*ExecutionResults) RemoveIndexByBlockID added in v0.39.4 

func (r *ExecutionResults) RemoveIndexByBlockID(blockID flow.Identifier) error

func (*ExecutionResults) Store added in v0.39.4 

func (r *ExecutionResults) Store(result *flow.ExecutionResult) error

type Guarantees added in v0.43.0 

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

Guarantees implements persistent storage for collection guarantees.

func NewGuarantees added in v0.43.0 

func NewGuarantees(
	collector module.CacheMetrics,
	db storage.DB,
	cacheSize uint,
	byCollectionIDCacheSize uint,
) *Guarantees

NewGuarantees creates a Guarantees instance, which stores collection guarantees. It supports storing, caching and retrieving by guaranteeID or the additionally indexed collection ID.

func (*Guarantees) ByCollectionID added in v0.43.0 

func (g *Guarantees) ByCollectionID(collID flow.Identifier) (*flow.CollectionGuarantee, error)

ByCollectionID retrieves the collection guarantee by collection ID. Expected errors during normal operations:

func (*Guarantees) ByID added in v0.43.0 

func (g *Guarantees) ByID(guaranteeID flow.Identifier) (*flow.CollectionGuarantee, error)

ByID returns the flow.CollectionGuarantee by its ID. Expected errors during normal operations:

type Headers added in v0.43.0 

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

Headers implements a simple read-only header storage around a DB.

func NewHeaders added in v0.43.0 

func NewHeaders(collector module.CacheMetrics, db storage.DB) *Headers

NewHeaders creates a Headers instance, which stores block headers. It supports storing, caching and retrieving by block ID and the additionally indexed by header height.

func (*Headers) BlockIDByHeight added in v0.43.0 

func (h *Headers) BlockIDByHeight(height uint64) (flow.Identifier, error)

BlockIDByHeight returns the block ID that is finalized at the given height. It is an optimized version of `ByHeight` that skips retrieving the block. Expected errors during normal operations:

func (*Headers) BlockIDByView added in v0.43.0 

func (h *Headers) BlockIDByView(view uint64) (flow.Identifier, error)

BlockIDByView returns the block ID that is certified at the given view. It is an optimized version of `ByView` that skips retrieving the block. Expected errors during normal operations:

  • `[storage.ErrNotFound] if no certified block is known at given view.

NOTE: this method is not available until next spork (mainnet27) or a migration that builds the index.

func (*Headers) ByBlockID added in v0.43.0 

func (h *Headers) ByBlockID(blockID flow.Identifier) (*flow.Header, error)

ByBlockID returns the header with the given ID. It is available for finalized blocks and those pending finalization. Error returns:

func (*Headers) ByHeight added in v0.43.0 

func (h *Headers) ByHeight(height uint64) (*flow.Header, error)

ByHeight returns the block with the given number. It is only available for finalized blocks. Error returns:

func (*Headers) ByParentID added in v0.43.0 

func (h *Headers) ByParentID(parentID flow.Identifier) ([]*flow.Header, error)

ByParentID finds all children for the given parent block. The returned headers might be unfinalized; if there is more than one, at least one of them has to be unfinalized. CAUTION: this method is not backed by a cache and therefore comparatively slow!

func (*Headers) ByView added in v0.43.0 

func (h *Headers) ByView(view uint64) (*flow.Header, error)

ByView returns the block with the given view. It is only available for certified blocks. Certified blocks are the blocks that have received QC. Hotstuff guarantees that for each view, at most one block is certified. Hence, the return value of `ByView` is guaranteed to be unique even for non-finalized blocks.

Expected errors during normal operations:

func (*Headers) Exists added in v0.43.0 

func (h *Headers) Exists(blockID flow.Identifier) (bool, error)

Exists returns true if a header with the given ID has been stored. No errors are expected during normal operation.

func (*Headers) FindHeaders added in v0.43.0 

func (h *Headers) FindHeaders(filter func(header *flow.Header) bool) ([]flow.Header, error)

func (*Headers) ProposalByBlockID added in v0.43.0 

func (h *Headers) ProposalByBlockID(blockID flow.Identifier) (*flow.ProposalHeader, error)

ProposalByBlockID returns the header with the given ID, along with the corresponding proposer signature. It is available for finalized blocks and those pending finalization. Error returns:

func (*Headers) RollbackExecutedBlock added in v0.43.0 

func (h *Headers) RollbackExecutedBlock(header *flow.Header) error

RollbackExecutedBlock update the executed block header to the given header. Intended to be used by Execution Nodes only, to roll back executed block height. This method is NOT CONCURRENT SAFE, the caller should make sure to call this method in a single thread.

type IdentifierAndUint32 added in v0.42.0 

type IdentifierAndUint32 [flow.IdentifierLen + 4]byte

func KeyFromBlockIDIndex added in v0.39.4 

func KeyFromBlockIDIndex(blockID flow.Identifier, txIndex uint32) IdentifierAndUint32

type Index added in v0.43.0 

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

Index implements a simple read-only payload storage around a badger DB.

func NewIndex added in v0.43.0 

func NewIndex(collector module.CacheMetrics, db storage.DB) *Index

func (*Index) ByBlockID added in v0.43.0 

func (i *Index) ByBlockID(blockID flow.Identifier) (*flow.Index, error)

type LatestPersistedSealedResult added in v0.43.0 

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

LatestPersistedSealedResult tracks the most recently persisted sealed execution result processed by the Access ingestion engine.

func NewLatestPersistedSealedResult added in v0.43.0 

func NewLatestPersistedSealedResult(
	progress storage.ConsumerProgress,
	headers storage.Headers,
	results storage.ExecutionResults,
) (*LatestPersistedSealedResult, error)

NewLatestPersistedSealedResult creates a new LatestPersistedSealedResult instance.

No errors are expected during normal operation,

func (*LatestPersistedSealedResult) BatchSet added in v0.43.0 

func (l *LatestPersistedSealedResult) BatchSet(resultID flow.Identifier, height uint64, batch storage.ReaderBatchWriter) error

BatchSet updates the latest persisted sealed result in a batch operation The resultID and height are added to the provided batch, and the local data is updated only after the batch is successfully committed.

No errors are expected during normal operation,

func (*LatestPersistedSealedResult) Latest added in v0.43.0 

func (l *LatestPersistedSealedResult) Latest() (flow.Identifier, uint64)

Latest returns the ID and height of the latest persisted sealed result.

type LightTransactionResults added in v0.39.4 

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

func NewLightTransactionResults added in v0.39.4 

func NewLightTransactionResults(collector module.CacheMetrics, db storage.DB, transactionResultsCacheSize uint) *LightTransactionResults

func (*LightTransactionResults) BatchStore added in v0.39.4 

func (tr *LightTransactionResults) BatchStore(blockID flow.Identifier, transactionResults []flow.LightTransactionResult, rw storage.ReaderBatchWriter) error

func (*LightTransactionResults) BatchStoreBadger added in v0.39.4 

func (tr *LightTransactionResults) BatchStoreBadger(blockID flow.Identifier, transactionResults []flow.LightTransactionResult, batch storage.BatchStorage) error

func (*LightTransactionResults) ByBlockID added in v0.39.4 

func (tr *LightTransactionResults) ByBlockID(blockID flow.Identifier) ([]flow.LightTransactionResult, error)

ByBlockID gets all transaction results for a block, ordered by transaction index

func (*LightTransactionResults) ByBlockIDTransactionID added in v0.39.4 

func (tr *LightTransactionResults) ByBlockIDTransactionID(blockID flow.Identifier, txID flow.Identifier) (*flow.LightTransactionResult, error)

ByBlockIDTransactionID returns the transaction result for the given block ID and transaction ID

func (*LightTransactionResults) ByBlockIDTransactionIndex added in v0.39.4 

func (tr *LightTransactionResults) ByBlockIDTransactionIndex(blockID flow.Identifier, txIndex uint32) (*flow.LightTransactionResult, error)

ByBlockIDTransactionIndex returns the transaction result for the given blockID and transaction index

type MyExecutionReceipts added in v0.39.4 

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

MyExecutionReceipts holds and indexes Execution Receipts. MyExecutionReceipts is implemented as a wrapper around badger.ExecutionReceipts The wrapper adds the ability to "MY execution receipt", from the viewpoint of an individual Execution Node.

func NewMyExecutionReceipts added in v0.39.4 

func NewMyExecutionReceipts(collector module.CacheMetrics, db storage.DB, receipts storage.ExecutionReceipts) *MyExecutionReceipts

NewMyExecutionReceipts creates instance of MyExecutionReceipts which is a wrapper wrapper around badger.ExecutionReceipts It's useful for execution nodes to keep track of produced execution receipts.

func (*MyExecutionReceipts) BatchRemoveIndexByBlockID added in v0.39.4 

func (m *MyExecutionReceipts) BatchRemoveIndexByBlockID(blockID flow.Identifier, rw storage.ReaderBatchWriter) error

BatchRemoveIndexByBlockID removes blockID-to-my-execution-receipt index entry keyed by a blockID in a provided batch No errors are expected during normal operation, even if no entries are matched. If Badger unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*MyExecutionReceipts) BatchStoreMyReceipt added in v0.39.4 

func (m *MyExecutionReceipts) BatchStoreMyReceipt(lctx lockctx.Proof, receipt *flow.ExecutionReceipt, rw storage.ReaderBatchWriter) error

BatchStoreMyReceipt stores blockID-to-my-receipt index entry keyed by blockID in a provided batch. No errors are expected during normal operation If entity fails marshalling, the error is wrapped in a generic error and returned. If Badger unexpectedly fails to process the request, the error is wrapped in a generic error and returned. If a different my receipt has been indexed for the same block, the error is wrapped in a generic error and returned.

func (*MyExecutionReceipts) MyReceipt added in v0.39.4 

func (m *MyExecutionReceipts) MyReceipt(blockID flow.Identifier) (*flow.ExecutionReceipt, error)

MyReceipt retrieves my receipt for the given block. Returns storage.ErrNotFound if no receipt was persisted for the block.

func (*MyExecutionReceipts) RemoveIndexByBlockID added in v0.39.4 

func (m *MyExecutionReceipts) RemoveIndexByBlockID(blockID flow.Identifier) error

type NodeDisallowList added in v0.41.0 

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

func NewNodeDisallowList added in v0.41.0 

func NewNodeDisallowList(db storage.DB) *NodeDisallowList

func (*NodeDisallowList) Retrieve added in v0.41.0 

func (dl *NodeDisallowList) Retrieve(disallowList *map[flow.Identifier]struct{}) error

Retrieve reads the set of disallowed nodes from the database. No error is returned if no database entry exists. No errors are expected during normal operations.

func (*NodeDisallowList) Store added in v0.41.0 

func (dl *NodeDisallowList) Store(disallowList map[flow.Identifier]struct{}) error

Store writes the given disallowList to the database. To avoid legacy entries in the database, we purge the entire database entry if disallowList is empty. No errors are expected during normal operations.

type Payloads added in v0.43.0 

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

func NewPayloads added in v0.43.0 

func NewPayloads(db storage.DB, index *Index, guarantees *Guarantees, seals *Seals, receipts *ExecutionReceipts,
	results *ExecutionResults) *Payloads

func (*Payloads) ByBlockID added in v0.43.0 

func (p *Payloads) ByBlockID(blockID flow.Identifier) (*flow.Payload, error)

type ProtocolKVStore added in v0.43.0 

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

ProtocolKVStore implements persistent storage for storing KV store snapshots.

func NewProtocolKVStore added in v0.43.0 

func NewProtocolKVStore(collector module.CacheMetrics,
	db storage.DB,
	kvStoreCacheSize uint,
	kvStoreByBlockIDCacheSize uint,
) *ProtocolKVStore

NewProtocolKVStore creates a ProtocolKVStore instance, which is a database holding KV store snapshots. It supports storing, caching and retrieving by ID or the additionally indexed block ID.

func (*ProtocolKVStore) BatchIndex added in v0.43.0 

func (s *ProtocolKVStore) BatchIndex(lctx lockctx.Proof, rw storage.ReaderBatchWriter, blockID flow.Identifier, stateID flow.Identifier) error

BatchIndex appends the following operation to the provided write batch: we extend the map from `blockID` to `stateID`, where `blockID` references the block that _proposes_ updated key-value store. BatchIndex is idempotent, i.e. it accepts repeated calls with the same pairs of (blockID , stateID). Per protocol convention, the block references the `stateID`. As the `blockID` is a collision-resistant hash, for the same `blockID`, BatchIndex will reject changing the data. Protocol convention:

  • Consider block B, whose ingestion might potentially lead to an updated KV store. For example, the KV store changes if we seal some execution results emitting specific service events.
  • For the key `blockID`, we use the identity of block B which _proposes_ this updated KV store.
  • CAUTION: The updated state requires confirmation by a QC and will only become active at the child block, _after_ validating the QC.

Expected errors during normal operations: - storage.ErrDataMismatch if a _different_ KV store for the given stateID has already been persisted

func (*ProtocolKVStore) BatchStore added in v0.43.0 

func (s *ProtocolKVStore) BatchStore(lctx lockctx.Proof, rw storage.ReaderBatchWriter, stateID flow.Identifier, data *flow.PSKeyValueStoreData) error

BatchStore persists the KV-store snapshot in the database using the given ID as key. BatchStore is idempotent, i.e. it accepts repeated calls with the same pairs of (stateID, kvStore). Here, the ID is expected to be a collision-resistant hash of the snapshot (including the ProtocolStateVersion). Hence, for the same ID, BatchStore will reject changing the data. Expected errors during normal operations: - storage.ErrDataMismatch if a _different_ KV store for the given stateID has already been persisted

func (*ProtocolKVStore) ByBlockID added in v0.43.0 

func (s *ProtocolKVStore) ByBlockID(blockID flow.Identifier) (*flow.PSKeyValueStoreData, error)

ByBlockID retrieves the kv-store snapshot that the block with the given ID proposes. CAUTION: this store snapshot requires confirmation by a QC and will only become active at the child block, _after_ validating the QC. Protocol convention:

  • Consider block B, whose ingestion might potentially lead to an updated KV store state. For example, the state changes if we seal some execution results emitting specific service events.
  • For the key `blockID`, we use the identity of block B which _proposes_ this updated KV store. As value, the hash of the resulting state at the end of processing B is to be used.
  • CAUTION: The updated state requires confirmation by a QC and will only become active at the child block, _after_ validating the QC.

Expected errors during normal operations:

  • storage.ErrNotFound if no snapshot has been indexed for the given block.

func (*ProtocolKVStore) ByID added in v0.43.0 

func (s *ProtocolKVStore) ByID(stateID flow.Identifier) (*flow.PSKeyValueStoreData, error)

ByID retrieves the KV store snapshot with the given state ID. Expected errors during normal operations:

  • storage.ErrNotFound if no snapshot with the given Identifier is known.

type QuorumCertificates added in v0.43.0 

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

QuorumCertificates implements persistent storage for quorum certificates.

func NewQuorumCertificates added in v0.43.0 

func NewQuorumCertificates(collector module.CacheMetrics, db storage.DB, cacheSize uint) *QuorumCertificates

NewQuorumCertificates Creates QuorumCertificates instance which is a database of quorum certificates which supports storing, caching and retrieving by block ID.

func (*QuorumCertificates) BatchStore added in v0.43.0 

func (q *QuorumCertificates) BatchStore(lctx lockctx.Proof, rw storage.ReaderBatchWriter, qc *flow.QuorumCertificate) error

BatchStore stores a Quorum Certificate as part of database batch update. QC is indexed by QC.BlockID.

Note: For the same block, different QCs can easily be constructed by selecting different sub-sets of the received votes (provided more than the minimal number of consensus participants voted, which is typically the case). In most cases, it is only important that a block has been certified, but irrelevant who specifically contributed to the QC. Therefore, we only store the first QC.

If *any* quorum certificate for QC.BlockID has already been stored, a `storage.ErrAlreadyExists` is returned (typically benign).

func (*QuorumCertificates) ByBlockID added in v0.43.0 

func (q *QuorumCertificates) ByBlockID(blockID flow.Identifier) (*flow.QuorumCertificate, error)

ByBlockID returns QC that certifies the block referred by blockID. * storage.ErrNotFound if no QC for blockID doesn't exist.

type ResultApprovals 

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

ResultApprovals implements persistent storage for result approvals.

CAUTION suitable only for _Verification Nodes_ for persisting their _own_ approvals!

  • In general, the Flow protocol requires multiple approvals for the same chunk from different verification nodes. In other words, there are multiple different approvals for the same chunk.
  • Internally, ResultApprovals populates an index from Executed Chunk ➜ ResultApproval. This is *only safe* for Verification Nodes when tracking their own approvals (for the same ExecutionResult, a Verifier will always produce the same approval)

func NewResultApprovals 

func NewResultApprovals(collector module.CacheMetrics, db storage.DB, lockManager lockctx.Manager) *ResultApprovals

func (*ResultApprovals) ByChunk 

func (r *ResultApprovals) ByChunk(resultID flow.Identifier, chunkIndex uint64) (*flow.ResultApproval, error)

ByChunk retrieves a ResultApproval by result ID and chunk index. The ResultApprovals store is only used within a verification node, where it is assumed that there is never more than one approval per chunk.

func (*ResultApprovals) ByID 

func (r *ResultApprovals) ByID(approvalID flow.Identifier) (*flow.ResultApproval, error)

ByID retrieves a ResultApproval by its ID

func (*ResultApprovals) StoreMyApproval added in v0.43.0 

func (r *ResultApprovals) StoreMyApproval(approval *flow.ResultApproval) func(lctx lockctx.Proof) error

StoreMyApproval returns a functor, whose execution

  • will store the given ResultApproval
  • and index it by result ID and chunk index.
  • requires storage.LockIndexResultApproval lock to be held by the caller

The functor's expected error returns during normal operation are:

  • `storage.ErrDataMismatch` if a *different* approval for the same key pair (ExecutionResultID, chunk index) is already indexed

CAUTION: the Flow protocol requires multiple approvals for the same chunk from different verification nodes. In other words, there are multiple different approvals for the same chunk. Therefore, the index Executed Chunk ➜ ResultApproval ID (populated here) is *only safe* to be used by Verification Nodes for tracking their own approvals.

For the same ExecutionResult, a Verifier will always produce the same approval. Therefore, this operation is idempotent, i.e. repeated calls with the *same inputs* are equivalent to just calling the method once; still the method succeeds on each call. However, when attempting to index *different* ResultApproval IDs for the same key (resultID, chunkIndex) this method returns an exception, as this should never happen for a correct Verification Node indexing its own approvals. It returns a functor so that some computation (such as computing approval ID) can be done before acquiring the lock.

type Seals added in v0.43.0 

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

func NewSeals added in v0.43.0 

func NewSeals(collector module.CacheMetrics, db storage.DB) *Seals

func (*Seals) ByID added in v0.43.0 

func (s *Seals) ByID(sealID flow.Identifier) (*flow.Seal, error)

func (*Seals) FinalizedSealForBlock added in v0.43.0 

func (s *Seals) FinalizedSealForBlock(blockID flow.Identifier) (*flow.Seal, error)

FinalizedSealForBlock returns the seal for the given block, only if that seal has been included in a finalized block. Returns storage.ErrNotFound if the block is unknown or unsealed.

func (*Seals) HighestInFork added in v0.43.0 

func (s *Seals) HighestInFork(blockID flow.Identifier) (*flow.Seal, error)

HighestInFork retrieves the highest seal that was included in the fork up to (and including) blockID. This method should return a seal for any block known to the node. Returns storage.ErrNotFound if blockID is unknown.

func (*Seals) Store added in v0.43.0 

func (s *Seals) Store(seal *flow.Seal) error

type ServiceEvents added in v0.39.4 

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

func NewServiceEvents added in v0.39.4 

func NewServiceEvents(collector module.CacheMetrics, db storage.DB) *ServiceEvents

func (*ServiceEvents) BatchRemoveByBlockID added in v0.39.4 

func (e *ServiceEvents) BatchRemoveByBlockID(blockID flow.Identifier, rw storage.ReaderBatchWriter) error

BatchRemoveByBlockID removes service events keyed by a blockID in provided batch No errors are expected during normal operation, even if no entries are matched. If Badger unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*ServiceEvents) BatchStore added in v0.39.4 

func (e *ServiceEvents) BatchStore(blockID flow.Identifier, events []flow.Event, rw storage.ReaderBatchWriter) error

BatchStore stores service events keyed by a blockID in provided batch No errors are expected during normal operation, even if no entries are matched. If Badger unexpectedly fails to process the request, the error is wrapped in a generic error and returned.

func (*ServiceEvents) ByBlockID added in v0.39.4 

func (e *ServiceEvents) ByBlockID(blockID flow.Identifier) ([]flow.Event, error)

ByBlockID returns the events for the given block ID

func (*ServiceEvents) RemoveByBlockID added in v0.39.4 

func (e *ServiceEvents) RemoveByBlockID(blockID flow.Identifier) error

RemoveByBlockID removes service events by block ID

type TransactionResultErrorMessages added in v0.39.4 

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

func NewTransactionResultErrorMessages added in v0.39.4 

func NewTransactionResultErrorMessages(collector module.CacheMetrics, db storage.DB, transactionResultsCacheSize uint) *TransactionResultErrorMessages

func (*TransactionResultErrorMessages) BatchStore added in v0.43.0 

func (t *TransactionResultErrorMessages) BatchStore(
	blockID flow.Identifier,
	transactionResultErrorMessages []flow.TransactionResultErrorMessage,
	batch storage.ReaderBatchWriter,
) error

BatchStore inserts a batch of transaction result error messages into a batch

No errors are expected during normal operation.

func (*TransactionResultErrorMessages) ByBlockID added in v0.39.4 

func (t *TransactionResultErrorMessages) ByBlockID(blockID flow.Identifier) ([]flow.TransactionResultErrorMessage, error)

ByBlockID gets all transaction result error messages for a block, ordered by transaction index. Note: This method will return an empty slice both if the block is not indexed yet and if the block does not have any errors.

No errors are expected during normal operations.

func (*TransactionResultErrorMessages) ByBlockIDTransactionID added in v0.39.4 

func (t *TransactionResultErrorMessages) ByBlockIDTransactionID(blockID flow.Identifier, transactionID flow.Identifier) (*flow.TransactionResultErrorMessage, error)

ByBlockIDTransactionID returns the transaction result error message for the given block ID and transaction ID

Expected errors during normal operation:

  • `storage.ErrNotFound` if no transaction error message is known at given block and transaction id.

func (*TransactionResultErrorMessages) ByBlockIDTransactionIndex added in v0.39.4 

func (t *TransactionResultErrorMessages) ByBlockIDTransactionIndex(blockID flow.Identifier, txIndex uint32) (*flow.TransactionResultErrorMessage, error)

ByBlockIDTransactionIndex returns the transaction result error message for the given blockID and transaction index

Expected errors during normal operation:

  • `storage.ErrNotFound` if no transaction error message is known at given block and transaction index.

func (*TransactionResultErrorMessages) Exists added in v0.39.4 

func (t *TransactionResultErrorMessages) Exists(blockID flow.Identifier) (bool, error)

Exists returns true if transaction result error messages for the given ID have been stored.

No errors are expected during normal operation.

func (*TransactionResultErrorMessages) Store added in v0.39.4 

func (t *TransactionResultErrorMessages) Store(blockID flow.Identifier, transactionResultErrorMessages []flow.TransactionResultErrorMessage) error

Store will store transaction result error messages for the given block ID.

No errors are expected during normal operation.

type TransactionResults added in v0.39.4 

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

func NewTransactionResults added in v0.39.4 

func NewTransactionResults(collector module.CacheMetrics, db storage.DB, transactionResultsCacheSize uint) *TransactionResults

func (*TransactionResults) BatchRemoveByBlockID added in v0.39.4 

func (tr *TransactionResults) BatchRemoveByBlockID(blockID flow.Identifier, batch storage.ReaderBatchWriter) error

BatchRemoveByBlockID batch removes transaction results by block ID

func (*TransactionResults) BatchStore added in v0.39.4 

func (tr *TransactionResults) BatchStore(blockID flow.Identifier, transactionResults []flow.TransactionResult, batch storage.ReaderBatchWriter) error

BatchStore will store the transaction results for the given block ID in a batch

func (*TransactionResults) ByBlockID added in v0.39.4 

func (tr *TransactionResults) ByBlockID(blockID flow.Identifier) ([]flow.TransactionResult, error)

ByBlockID gets all transaction results for a block, ordered by transaction index

func (*TransactionResults) ByBlockIDTransactionID added in v0.39.4 

func (tr *TransactionResults) ByBlockIDTransactionID(blockID flow.Identifier, txID flow.Identifier) (*flow.TransactionResult, error)

ByBlockIDTransactionID returns the runtime transaction result for the given block ID and transaction ID

func (*TransactionResults) ByBlockIDTransactionIndex added in v0.39.4 

func (tr *TransactionResults) ByBlockIDTransactionIndex(blockID flow.Identifier, txIndex uint32) (*flow.TransactionResult, error)

ByBlockIDTransactionIndex returns the runtime transaction result for the given block ID and transaction index

func (*TransactionResults) RemoveByBlockID added in v0.39.4 

func (tr *TransactionResults) RemoveByBlockID(blockID flow.Identifier) error

RemoveByBlockID removes transaction results by block ID

type Transactions added in v0.39.4 

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

Transactions ...

func NewTransactions added in v0.39.4 

func NewTransactions(cacheMetrics module.CacheMetrics, db storage.DB) *Transactions

NewTransactions ...

func (*Transactions) BatchStore added in v0.43.0 

func (t *Transactions) BatchStore(tx *flow.TransactionBody, batch storage.ReaderBatchWriter) error

BatchStore stores transaction within a batch operation. No errors are expected during normal operations

func (*Transactions) ByID added in v0.39.4 

func (t *Transactions) ByID(txID flow.Identifier) (*flow.TransactionBody, error)

func (*Transactions) RemoveBatch added in v0.41.0 

func (t *Transactions) RemoveBatch(rw storage.ReaderBatchWriter, txID flow.Identifier) error

RemoveBatch removes a transaction by fingerprint.

func (*Transactions) Store added in v0.39.4 

func (t *Transactions) Store(flowTx *flow.TransactionBody) error

type TwoIdentifier added in v0.42.0 

type TwoIdentifier [flow.IdentifierLen * 2]byte

func KeyFromBlockIDTransactionID added in v0.39.4 

func KeyFromBlockIDTransactionID(blockID flow.Identifier, txID flow.Identifier) TwoIdentifier

type VersionBeacons added in v0.39.2 

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

func NewVersionBeacons added in v0.39.2 

func NewVersionBeacons(db storage.DB) *VersionBeacons

func (*VersionBeacons) Highest added in v0.39.2 

func (r *VersionBeacons) Highest(
	belowOrEqualTo uint64,
) (*flow.SealedVersionBeacon, error)

Source Files

View all Source files

Directories

Path Synopsis
inmemory
unsynchronized

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.