Enum AuthorActivity

pub enum AuthorActivity<T: Config> {
    SessionValidator,
    ElectionCandidate,
    ElectionWinner,
    Indeterminate(PhantomData<T>),
}

Represents the current blocking duty being performed by an author.

This enum is used as the activity context for RoleActivity, indicating why an author is considered active and therefore temporarily unable to perform certain operations (e.g. resigning or withdrawing collateral).

Each variant must map to a user-facing, actionable [DispatchError] explaining the ongoing duty and how or when it can be exited.

Invariants

• An author may be blocked by at most one activity at a time.
• Activity states are derived, not persisted.

Design Notes

• Activity is inferred from session state, affidavits, and election results.
• No explicit activity storage is maintained.
• This enum is strictly descriptive and has no side effects.

Variants

SessionValidator

The author is actively validating in the current session.

ElectionCandidate

The author has submitted an affidavit and is participating in the ongoing election process.

ElectionWinner

The author has won the election and is waiting to enter the next validation session.

Indeterminate(PhantomData<T>)

Internal fallback variant used when activity cannot be determined conclusively.

Trait Implementations

impl<T: Clone + Config> Clone for AuthorActivity<T>

fn clone(&self) -> AuthorActivity<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Config> Debug for AuthorActivity<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for AuthorActivity<T>

where PhantomData<T>: Decode,

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<T: Config> Encode for AuthorActivity<T>

where PhantomData<T>: Encode,

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<T: Config> Into<DispatchError> for AuthorActivity<T>

fn into(self) -> DispatchError

Converts this type into the (usually inferred) input type.

impl<T: Config> MaxEncodedLen for AuthorActivity<T>

where PhantomData<T>: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: PartialEq + Config> PartialEq for AuthorActivity<T>

fn eq(&self, other: &AuthorActivity<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> TypeInfo for AuthorActivity<T>

where PhantomData<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = AuthorActivity<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Copy + Config> Copy for AuthorActivity<T>

impl<T: Config> DecodeWithMemTracking for AuthorActivity<T>

where PhantomData<T>: DecodeWithMemTracking,

impl<T: Config> EncodeLike for AuthorActivity<T>

where PhantomData<T>: Encode,

impl<T: Eq + Config> Eq for AuthorActivity<T>

impl<T: Config> StructuralPartialEq for AuthorActivity<T>