Enum polkadot_node_primitives::disputes::DisputeStatus

pub enum DisputeStatus {
    Active,
    ConcludedFor(Timestamp),
    ConcludedAgainst(Timestamp),
    Confirmed,
}

The status of dispute.

As managed by the dispute coordinator.

NOTE: This status is persisted to the database, any changes have to be versioned and a db migration will be needed.

Variants

Active

The dispute is active and unconcluded.

ConcludedFor(Timestamp)

The dispute has been concluded in favor of the candidate since the given timestamp.

ConcludedAgainst(Timestamp)

The dispute has been concluded against the candidate since the given timestamp.

This takes precedence over ConcludedFor in the case that both are true, which is impossible unless a large amount of validators are participating on both sides.

Confirmed

Dispute has been confirmed (more than byzantine_threshold have already participated/ or we have seen the candidate included already/participated successfully ourselves).

Implementations

impl DisputeStatus

pub fn active() -> DisputeStatus

Initialize the status to the active state.

pub fn confirm(self) -> DisputeStatus

Move status to confirmed status, if not yet concluded/confirmed already.

pub fn is_confirmed_concluded(&self) -> bool

Check whether the dispute is not a spam dispute.

pub fn has_concluded_for(&self) -> bool

Concluded valid?

pub fn has_concluded_against(&self) -> bool

Concluded invalid?

pub fn conclude_for(self, now: Timestamp) -> DisputeStatus

Transition the status to a new status after observing the dispute has concluded for the candidate. This may be a no-op if the status was already concluded.

pub fn conclude_against(self, now: Timestamp) -> DisputeStatus

Transition the status to a new status after observing the dispute has concluded against the candidate. This may be a no-op if the status was already concluded.

pub fn is_possibly_invalid(&self) -> bool

Whether the disputed candidate is possibly invalid.

pub fn concluded_at(&self) -> Option<Timestamp>

Yields the timestamp this dispute concluded at, if any.

Trait Implementations

impl Clone for DisputeStatus

fn clone(&self) -> DisputeStatus

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DisputeStatus

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

Formats the value using the given formatter.

impl Decode for DisputeStatus

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Encode for DisputeStatus

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for DisputeStatus

fn eq(&self, other: &DisputeStatus) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DisputeStatus

impl EncodeLike for DisputeStatus

impl StructuralPartialEq for DisputeStatus