Enum polkadot_node_subsystem_types::messages::AvailabilityStoreMessage

pub enum AvailabilityStoreMessage {
    QueryAvailableData(CandidateHash, Sender<Option<AvailableData>>),
    QueryDataAvailability(CandidateHash, Sender<bool>),
    QueryChunk(CandidateHash, ValidatorIndex, Sender<Option<ErasureChunk>>),
    QueryChunkSize(CandidateHash, Sender<Option<usize>>),
    QueryAllChunks(CandidateHash, Sender<Vec<(ValidatorIndex, ErasureChunk)>>),
    QueryChunkAvailability(CandidateHash, ValidatorIndex, Sender<bool>),
    StoreChunk {
        candidate_hash: CandidateHash,
        validator_index: ValidatorIndex,
        chunk: ErasureChunk,
        tx: Sender<Result<(), ()>>,
    },
    StoreAvailableData {
        candidate_hash: CandidateHash,
        n_validators: u32,
        available_data: AvailableData,
        expected_erasure_root: Hash,
        core_index: CoreIndex,
        node_features: NodeFeatures,
        tx: Sender<Result<(), StoreAvailableDataError>>,
    },
}

Availability store subsystem message.

Variants

QueryAvailableData(CandidateHash, Sender<Option<AvailableData>>)

Query a AvailableData from the AV store.

QueryDataAvailability(CandidateHash, Sender<bool>)

Query whether a AvailableData exists within the AV Store.

This is useful in cases when existence matters, but we don’t want to necessarily pass around multiple megabytes of data to get a single bit of information.

QueryChunk(CandidateHash, ValidatorIndex, Sender<Option<ErasureChunk>>)

Query an ErasureChunk from the AV store by the candidate hash and validator index.

QueryChunkSize(CandidateHash, Sender<Option<usize>>)

Get the size of an ErasureChunk from the AV store by the candidate hash.

QueryAllChunks(CandidateHash, Sender<Vec<(ValidatorIndex, ErasureChunk)>>)

Query all chunks that we have for the given candidate hash.

QueryChunkAvailability(CandidateHash, ValidatorIndex, Sender<bool>)

Query whether an ErasureChunk exists within the AV Store.

This is useful in cases like bitfield signing, when existence matters, but we don’t want to necessarily pass around large quantities of data to get a single bit of information.

StoreChunk

Store an ErasureChunk in the AV store.

Return Ok(()) if the store operation succeeded, Err(()) if it failed.

Fields

candidate_hash: CandidateHash

A hash of the candidate this chunk belongs to.

validator_index: ValidatorIndex

Validator index. May not be equal to the chunk index.

chunk: ErasureChunk

The chunk itself.

tx: Sender<Result<(), ()>>

Sending side of the channel to send result to.

StoreAvailableData

Computes and checks the erasure root of AvailableData before storing all of its chunks in the AV store.

Return Ok(()) if the store operation succeeded, Err(StoreAvailableData) if it failed.

Fields

candidate_hash: CandidateHash

A hash of the candidate this available_data belongs to.

n_validators: u32

The number of validators in the session.

available_data: AvailableData

The AvailableData itself.

expected_erasure_root: Hash

Erasure root we expect to get after chunking.

core_index: CoreIndex

Core index where the candidate was backed.

node_features: NodeFeatures

Node features at the candidate relay parent. Used for computing the validator->chunk mapping.

tx: Sender<Result<(), StoreAvailableDataError>>

Sending side of the channel to send result to.

Trait Implementations

impl Debug for AvailabilityStoreMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.