Documentation
¶
Index ¶
- Variables
- type Blocks
- type ChunkDataPacks
- type Cleaner
- type ClusterBlocks
- type ClusterPayloads
- type Collections
- type Commits
- type EpochCommits
- type EpochSetups
- type EpochStatuses
- type Events
- type ExecutionReceipts
- type ExecutionResults
- type Guarantees
- type Headers
- type Identities
- type Index
- type Ledger
- type LedgerVerifier
- type Payloads
- type Seals
- type TransactionResults
- type Transactions
Constants ¶
This section is empty.
Variables ¶
Functions ¶
This section is empty.
Types ¶
type Blocks ¶
type Blocks interface { // Store will atomically store a block with all its dependencies. Store(block *flow.Block) error // StoreTx allows us to store a new block, including its payload & header, as part of a DB transaction, while // still going through the caching layer. StoreTx(block *flow.Block) func(*badger.Txn) error // ByID returns the block with the given hash. It is available for // finalized and ambiguous blocks. ByID(blockID flow.Identifier) (*flow.Block, error) // ByHeight returns the block at the given height. It is only available // for finalized blocks. ByHeight(height uint64) (*flow.Block, error) // ByCollectionID returns the block for the given collection ID. ByCollectionID(collID flow.Identifier) (*flow.Block, error) // IndexBlockForCollections indexes the block each collection was // included in. IndexBlockForCollections(blockID flow.Identifier, collIDs []flow.Identifier) error // UpdateLastFullBlockHeight updates the FullBlockHeight index // The FullBlockHeight index indicates that block for which all collections have been received UpdateLastFullBlockHeight(height uint64) error // GetLastFullBlockHeight retrieves the FullBlockHeight GetLastFullBlockHeight() (height uint64, err error) }
Blocks represents persistent storage for blocks.
type ChunkDataPacks ¶
type ChunkDataPacks interface { // Store inserts the chunk header, keyed by chunk ID. Store(c *flow.ChunkDataPack) error // Remove removes the chunk data for the given chunk ID, if it exists. Remove(chunkID flow.Identifier) error // ByChunkID returns the chunk data for the given a chunk ID. ByChunkID(chunkID flow.Identifier) (*flow.ChunkDataPack, error) }
ChunkDataPacks represents persistent storage for chunk data packs.
type ClusterBlocks ¶
type ClusterBlocks interface { // Store stores the cluster block. Store(block *cluster.Block) error // ByID returns the block with the given ID. ByID(blockID flow.Identifier) (*cluster.Block, error) // ByHeight returns the block with the given height. Only available for // finalized blocks. ByHeight(height uint64) (*cluster.Block, error) }
type ClusterPayloads ¶
type ClusterPayloads interface { // Store stores and indexes the given cluster payload. Store(blockID flow.Identifier, payload *cluster.Payload) error // ByBlockID returns the cluster payload for the given block ID. ByBlockID(blockID flow.Identifier) (*cluster.Payload, error) }
ClusterPayloads handles storing and retrieving payloads for collection node cluster consensus.
type Collections ¶
type Collections interface { // StoreLight inserts the collection. It does not insert, nor check // existence of, the constituent transactions. StoreLight(collection *flow.LightCollection) error // Store inserts the collection keyed by ID and all constituent // transactions. Store(collection *flow.Collection) error // Remove removes the collection and all constituent transactions. Remove(collID flow.Identifier) error // LightByID returns collection with the given ID. Only retrieves // transaction hashes. LightByID(collID flow.Identifier) (*flow.LightCollection, error) // ByID returns the collection with the given ID, including all // transactions within the collection. ByID(collID flow.Identifier) (*flow.Collection, error) // StoreLightAndIndexByTransaction inserts the collection (only transactions hashes) and adds a transaction id index // for each of the transactions within the collection StoreLightAndIndexByTransaction(collection *flow.LightCollection) error // LightByTransactionID returns the collection for the given transaction ID. Only retrieves // transaction hashes. LightByTransactionID(txID flow.Identifier) (*flow.LightCollection, error) }
Collections represents persistent storage for collections.
type Commits ¶
type Commits interface { // Store will store a commit in the persistent storage. Store(blockID flow.Identifier, commit flow.StateCommitment) error // ByBlockID will retrieve a commit by its ID from persistent storage. ByBlockID(blockID flow.Identifier) (flow.StateCommitment, error) RemoveByBlockID(blockID flow.Identifier) error }
Commits represents persistent storage for state commitments.
type EpochCommits ¶
type EpochCommits interface { // StoreTx allows us to store a new epoch commit in a DB transaction while updating the cache. StoreTx(commit *flow.EpochCommit) func(*badger.Txn) error // ByCommitID will return the EpochCommit event by its ID. ByID(flow.Identifier) (*flow.EpochCommit, error) }
type EpochSetups ¶
type EpochSetups interface { // StoreTx allows us to store a new epoch setup in a DB transaction while going through the cache. StoreTx(*flow.EpochSetup) func(*badger.Txn) error // ByID will return the EpochSetup event by its ID. ByID(flow.Identifier) (*flow.EpochSetup, error) }
type EpochStatuses ¶
type EpochStatuses interface { // StoreTx stores a new epoch state in a DB transaction while going through the cache. StoreTx(blockID flow.Identifier, state *flow.EpochStatus) func(*badger.Txn) error // ByBlockID will return the epoch status for the given block ByBlockID(flow.Identifier) (*flow.EpochStatus, error) }
type Events ¶
type Events interface { // Store will store events for the given block ID Store(blockID flow.Identifier, events []flow.Event) error // ByBlockID returns the events for the given block ID ByBlockID(blockID flow.Identifier) ([]flow.Event, error) // ByBlockIDTransactionID returns the events for the given block ID and transaction ID ByBlockIDTransactionID(blockID flow.Identifier, transactionID flow.Identifier) ([]flow.Event, error) // ByBlockIDEventType returns the events for the given block ID and event type ByBlockIDEventType(blockID flow.Identifier, eventType flow.EventType) ([]flow.Event, error) }
Events represents persistent storage for events.
type ExecutionReceipts ¶
type ExecutionReceipts interface { // Store stores an execution receipt. Store(result *flow.ExecutionReceipt) error // RemoveByBlockID receipt by block ID RemoveByBlockID(blockID flow.Identifier) error // ByID retrieves an execution receipt by its ID. ByID(resultID flow.Identifier) (*flow.ExecutionReceipt, error) // Index indexes an execution receipt by block ID. Index(blockID flow.Identifier, resultID flow.Identifier) error // ByBlockID retrieves an execution receipt by block ID. ByBlockID(blockID flow.Identifier) (*flow.ExecutionReceipt, error) }
type ExecutionResults ¶
type ExecutionResults interface { // Store stores an execution result. Store(result *flow.ExecutionResult) error // ByID retrieves an execution result by its ID. ByID(resultID flow.Identifier) (*flow.ExecutionResult, error) // Index indexes an execution result by block ID. Index(blockID flow.Identifier, resultID flow.Identifier) error // ByBlockID retrieves an execution result by block ID. ByBlockID(blockID flow.Identifier) (*flow.ExecutionResult, error) RemoveByBlockID(blockID flow.Identifier) error }
type Guarantees ¶
type Guarantees interface { // Store inserts the collection guarantee. Store(guarantee *flow.CollectionGuarantee) error // ByCollectionID retrieves the collection guarantee by collection ID. ByCollectionID(collID flow.Identifier) (*flow.CollectionGuarantee, error) }
Guarantees represents persistent storage for collection guarantees.
type Headers ¶
type Headers interface { // Store will store a header. Store(header *flow.Header) error // ByBlockID returns the header with the given ID. It is available for // finalized and ambiguous blocks. ByBlockID(blockID flow.Identifier) (*flow.Header, error) // ByHeight returns the block with the given number. It is only available // for finalized blocks. ByHeight(height uint64) (*flow.Header, error) // Find 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. ByParentID(parentID flow.Identifier) ([]*flow.Header, error) }
Headers represents persistent storage for blocks.
type Identities ¶
type Identities interface { // Store will store the given identity. Store(identity *flow.Identity) error // ByNodeID will retrieve the identity for a node. ByNodeID(nodeID flow.Identifier) (*flow.Identity, error) }
Identities represents the simple storage for identities.
type Index ¶
type Index interface { // Store stores the index for a block payload. Store(blockID flow.Identifier, index *flow.Index) error // ByBlockID retrieves the index for a block payload. ByBlockID(blockID flow.Identifier) (*flow.Index, error) }
type Ledger ¶
type Ledger interface { module.ReadyDoneAware EmptyStateCommitment() flow.StateCommitment // Trusted methods (without proof) // Get registers at specific StateCommitment by a list of register ids GetRegisters(registerIDs []flow.RegisterID, stateCommitment flow.StateCommitment) (values []flow.RegisterValue, err error) // Batched atomic updates of a subset of registers at specific state UpdateRegisters(registerIDs []flow.RegisterID, values []flow.RegisterValue, stateCommitment flow.StateCommitment) (newStateCommitment flow.StateCommitment, err error) // Untrusted methods (providing proofs) // Get registers at specific StateCommitment by a list of register ids with proofs GetRegistersWithProof(registerIDs []flow.RegisterID, stateCommitment flow.StateCommitment) (values []flow.RegisterValue, proofs []flow.StorageProof, err error) // Batched atomic updates of a subset of registers at specific state with proofs UpdateRegistersWithProof(registerIDs []flow.RegisterID, values []flow.RegisterValue, stateCommitment flow.StateCommitment) (newStateCommitment flow.StateCommitment, proofs []flow.StorageProof, err error) DiskSize() (int64, error) }
Ledger takes care of storing registers (key, value pairs) providing proof of correctness we aim to store a state of the order of 10^10 registers with up to 1M historic state versions
type LedgerVerifier ¶
type LedgerVerifier interface { // verify if a provided proof for getRegisters is accurate VerifyRegistersProof(registerIDs []flow.RegisterID, stateCommitment flow.StateCommitment, values []flow.RegisterValue, proof []flow.StorageProof) (verified bool, err error) }
LedgerVerifier should be designed as an standalone package to verify proofs of storage
type Payloads ¶
type Payloads interface { // Store will store a payload and index its contents. Store(blockID flow.Identifier, payload *flow.Payload) error // ByBlockID returns the payload with the given hash. It is available for // finalized and ambiguous blocks. ByBlockID(blockID flow.Identifier) (*flow.Payload, error) }
Payloads represents persistent storage for payloads.
type Seals ¶
type Seals interface { // Store inserts the seal. Store(guarantee *flow.Seal) error // ByID retrieves the seal by the collection // fingerprint. ByID(sealID flow.Identifier) (*flow.Seal, error) // ByBlockID retrieves the last seal in the chain of seals for the block. ByBlockID(sealedID flow.Identifier) (*flow.Seal, error) }
Seals represents persistent storage for seals.
type TransactionResults ¶
type TransactionResults interface { // Store inserts the transaction result Store(blockID flow.Identifier, transactionResult *flow.TransactionResult) error // BatchStore inserts a batch of transaction result BatchStore(blockID flow.Identifier, transactionResults []flow.TransactionResult) error // ByBlockIDTransactionID returns the transaction result for the given block ID and transaction ID ByBlockIDTransactionID(blockID flow.Identifier, transactionID flow.Identifier) (*flow.TransactionResult, error) }
TransactionResults represents persistent storage for transaction result
type Transactions ¶
type Transactions interface { // Store inserts the transaction, keyed by fingerprint. Duplicate transaction insertion is ignored Store(tx *flow.TransactionBody) error // ByID returns the transaction for the given fingerprint. ByID(txID flow.Identifier) (*flow.TransactionBody, error) }
Transactions represents persistent storage for transactions.
Source Files
¶
- blocks.go
- chunkDataPacks.go
- cleaner.go
- cluster_blocks.go
- cluster_payloads.go
- collections.go
- commits.go
- epoch_commits.go
- epoch_setups.go
- epoch_statuses.go
- errors.go
- events.go
- guarantees.go
- headers.go
- identities.go
- index.go
- ledger.go
- payloads.go
- receipts.go
- results.go
- seals.go
- transaction_results.go
- transactions.go
Directories
¶
Path | Synopsis |
---|---|
Package mocks is a generated GoMock package.
|
Package mocks is a generated GoMock package. |