Enum malus::interceptor::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: H256,
        core_index: CoreIndex,
        node_features: BitVec<u8>,
        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: H256

Erasure root we expect to get after chunking.

core_index: CoreIndex

Core index where the candidate was backed.

node_features: BitVec<u8>

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 AssociateOutgoing for AvailabilityStoreMessage

type OutgoingMessages = AvailabilityStoreOutgoingMessages

The associated outgoing messages for a subsystem that consumes the message Self.

impl Debug for AvailabilityStoreMessage

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

Formats the value using the given formatter.

impl From<AvailabilityStoreMessage> for AllMessages

fn from(message: AvailabilityStoreMessage) -> AllMessages

Converts to this type from the input type.

impl TryFrom<AllMessages> for AvailabilityStoreMessage

type Error = ()

The type returned in the event of a conversion error.

fn try_from( message: AllMessages, ) -> Result<AvailabilityStoreMessage, <AvailabilityStoreMessage as TryFrom<AllMessages>>::Error>

Performs the conversion.