Enum malus::interceptor::ProspectiveParachainsMessage

pub enum ProspectiveParachainsMessage {
    IntroduceSecondedCandidate(IntroduceSecondedCandidateRequest, Sender<bool>),
    CandidateBacked(Id, CandidateHash),
    GetBackableCandidates(H256, Id, u32, HashSet<CandidateHash>, Sender<Vec<(CandidateHash, H256)>>),
    GetHypotheticalMembership(HypotheticalMembershipRequest, Sender<Vec<(HypotheticalCandidate, Vec<H256>)>>),
    GetMinimumRelayParents(H256, Sender<Vec<(Id, u32)>>),
    GetProspectiveValidationData(ProspectiveValidationDataRequest, Sender<Option<PersistedValidationData>>),
}

Messages sent to the Prospective Parachains subsystem.

Variants

IntroduceSecondedCandidate(IntroduceSecondedCandidateRequest, Sender<bool>)

Inform the Prospective Parachains Subsystem of a new seconded candidate.

The response sender returns false if the candidate was rejected by prospective parachains, true otherwise (if it was accepted or already present)

CandidateBacked(Id, CandidateHash)

Inform the Prospective Parachains Subsystem that a previously introduced candidate has been backed. This requires that the candidate was successfully introduced in the past.

GetBackableCandidates(H256, Id, u32, HashSet<CandidateHash>, Sender<Vec<(CandidateHash, H256)>>)

Try getting N backable candidate hashes along with their relay parents for the given parachain, under the given relay-parent hash, which is a descendant of the given ancestors. Timed out ancestors should not be included in the collection. N should represent the number of scheduled cores of this ParaId. A timed out ancestor frees the cores of all of its descendants, so if there’s a hole in the supplied ancestor path, we’ll get candidates that backfill those timed out slots first. It may also return less/no candidates, if there aren’t enough backable candidates recorded.

GetHypotheticalMembership(HypotheticalMembershipRequest, Sender<Vec<(HypotheticalCandidate, Vec<H256>)>>)

Get the hypothetical or actual membership of candidates with the given properties under the specified active leave’s fragment chain.

For each candidate, we return a vector of leaves where the candidate is present or could be added. “Could be added” either means that the candidate can be added to the chain right now or could be added in the future (we may not have its ancestors yet). Note that even if we think it could be added in the future, we may find out that it was invalid, as time passes. If an active leaf is not in the vector, it means that there’s no chance this candidate will become valid under that leaf in the future.

If fragment_chain_relay_parent in the request is Some(), the return vector can only contain this relay parent (or none).

GetMinimumRelayParents(H256, Sender<Vec<(Id, u32)>>)

Get the minimum accepted relay-parent number for each para in the fragment chain for the given relay-chain block hash.

That is, if the block hash is known and is an active leaf, this returns the minimum relay-parent block number in the same branch of the relay chain which is accepted in the fragment chain for each para-id.

If the block hash is not an active leaf, this will return an empty vector.

Para-IDs which are omitted from this list can be assumed to have no valid candidate relay-parents under the given relay-chain block hash.

Para-IDs are returned in no particular order.

GetProspectiveValidationData(ProspectiveValidationDataRequest, Sender<Option<PersistedValidationData>>)

Get the validation data of some prospective candidate. The candidate doesn’t need to be part of any fragment chain, but this only succeeds if the parent head-data and relay-parent are part of the CandidateStorage (meaning that it’s a candidate which is part of some fragment chain or which prospective-parachains predicted will become part of some fragment chain).

Trait Implementations

impl AssociateOutgoing for ProspectiveParachainsMessage

type OutgoingMessages = ProspectiveParachainsOutgoingMessages

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

impl Debug for ProspectiveParachainsMessage

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

Formats the value using the given formatter.

impl From<ProspectiveParachainsMessage> for AllMessages

fn from(message: ProspectiveParachainsMessage) -> AllMessages

Converts to this type from the input type.

impl TryFrom<AllMessages> for ProspectiveParachainsMessage

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.