Enum malus::interceptor::DisputeCoordinatorMessage

pub enum DisputeCoordinatorMessage {
    ImportStatements {
        candidate_receipt: CandidateReceiptV2,
        session: u32,
        statements: Vec<(SignedDisputeStatement, ValidatorIndex)>,
        pending_confirmation: Option<Sender<ImportStatementsResult>>,
    },
    RecentDisputes(Sender<Vec<(u32, CandidateHash, DisputeStatus)>>),
    ActiveDisputes(Sender<Vec<(u32, CandidateHash, DisputeStatus)>>),
    QueryCandidateVotes(Vec<(u32, CandidateHash)>, Sender<Vec<(u32, CandidateHash, CandidateVotes)>>),
    IssueLocalStatement(u32, CandidateHash, CandidateReceiptV2, bool),
    DetermineUndisputedChain {
        base: (u32, H256),
        block_descriptions: Vec<BlockDescription>,
        tx: Sender<(u32, H256)>,
    },
}

Messages received by the dispute coordinator subsystem.

NOTE: Any response oneshots might get cancelled if the DisputeCoordinator was not yet properly initialized for some reason.

Variants

ImportStatements

Import statements by validators about a candidate.

The subsystem will silently discard ancient statements or sets of only dispute-specific statements for candidates that are previously unknown to the subsystem. The former is simply because ancient data is not relevant and the latter is as a DoS prevention mechanism. Both backing and approval statements already undergo anti-DoS procedures in their respective subsystems, but statements cast specifically for disputes are not necessarily relevant to any candidate the system is already aware of and thus present a DoS vector. Our expectation is that nodes will notify each other of disputes over the network by providing (at least) 2 conflicting statements, of which one is either a backing or validation statement.

This does not do any checking of the message signature.

Fields

candidate_receipt: CandidateReceiptV2

The candidate receipt itself.

session: u32

The session the candidate appears in.

statements: Vec<(SignedDisputeStatement, ValidatorIndex)>

Statements, with signatures checked, by validators participating in disputes.

The validator index passed alongside each statement should correspond to the index of the validator in the set.

pending_confirmation: Option<Sender<ImportStatementsResult>>

Inform the requester once we finished importing (if a sender was provided).

This is:

• we discarded the votes because - they were ancient or otherwise invalid (result: InvalidImport) - or we were not able to recover availability for an unknown candidate (result: InvalidImport) - or were known already (in that case the result will still be ValidImport)
• or we recorded them because (ValidImport) - we cast our own vote already on that dispute - or we have approval votes on that candidate - or other explicit votes on that candidate already recorded - or recovered availability for the candidate - or the imported statements are backing/approval votes, which are always accepted.

RecentDisputes(Sender<Vec<(u32, CandidateHash, DisputeStatus)>>)

Fetch a list of all recent disputes the coordinator is aware of. These are disputes which have occurred any time in recent sessions, and which may have already concluded.

ActiveDisputes(Sender<Vec<(u32, CandidateHash, DisputeStatus)>>)

Fetch a list of all active disputes that the coordinator is aware of. These disputes are either not yet concluded or recently concluded.

QueryCandidateVotes(Vec<(u32, CandidateHash)>, Sender<Vec<(u32, CandidateHash, CandidateVotes)>>)

Get candidate votes for a candidate.

IssueLocalStatement(u32, CandidateHash, CandidateReceiptV2, bool)

Sign and issue local dispute votes. A value of true indicates validity, and false invalidity.

DetermineUndisputedChain

Determine the highest undisputed block within the given chain, based on where candidates were included. If even the base block should not be finalized due to a dispute, then None should be returned on the channel.

The block descriptions begin counting upwards from the block after the given base_number. The base_number is typically the number of the last finalized block but may be slightly higher. This block is inevitably going to be finalized so it is not accounted for by this function.

Fields

base: (u32, H256)

The lowest possible block to vote on.

block_descriptions: Vec<BlockDescription>

Descriptions of all the blocks counting upwards from the block after the base number

tx: Sender<(u32, H256)>

The block to vote on, might be base in case there is no better.

Trait Implementations

impl AssociateOutgoing for DisputeCoordinatorMessage

type OutgoingMessages = DisputeCoordinatorOutgoingMessages

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

impl Debug for DisputeCoordinatorMessage

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

Formats the value using the given formatter.

impl From<DisputeCoordinatorMessage> for AllMessages

fn from(message: DisputeCoordinatorMessage) -> AllMessages

Converts to this type from the input type.

impl TryFrom<AllMessages> for DisputeCoordinatorMessage

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.