Enum Phase

pub enum Phase<T: Config> {
    Off,
    Signed(BlockNumberFor<T>),
    SignedValidation(BlockNumberFor<T>),
    Unsigned(BlockNumberFor<T>),
    Snapshot(PageIndex),
    Done,
    Export(PageIndex),
    Emergency,
}

Current phase of the pallet.

Variants

Off

Nothing is happening, but it might.

Signed(BlockNumberFor<T>)

Signed phase is open.

The inner value is the number of blocks left in this phase.

SignedValidation(BlockNumberFor<T>)

We are validating results.

This always follows the signed phase, and is a window of time in which we try to validate our signed results.

The inner value is the number of blocks left in this phase.

Unsigned(BlockNumberFor<T>)

Unsigned phase.

The inner value is the number of blocks left in this phase.

We do not yet check whether the unsigned phase is active or passive. The intent is for the blockchain to be able to declare: “I believe that there exists an adequate signed solution,” advising validators not to bother running the unsigned offchain worker.

As validator nodes are free to edit their OCW code, they could simply ignore this advisory and always compute their own solution. However, by default, when the unsigned phase is passive, the offchain workers will not bother running.

Snapshot(PageIndex)

Snapshot is being created. No other operation is allowed. This can be one or more blocks. The inner value should be read as “remaining number of pages are left to be fetched”. Thus, if inner value is 0 if the snapshot is complete and we are ready to move on.

This value should be interpreted after on_initialize of this pallet has already been called.

Done

Snapshot is done, and we are waiting for Export to kick in.

Export(PageIndex)

Exporting has begun, and the given page was the last one received.

Once this is active, no more signed or solutions will be accepted.

Emergency

The emergency phase. This is could be enabled by one of the fallbacks, and locks the pallet such that only governance can change the state.

Implementations

impl<T: Config> Phase<T>

pub fn next(self) -> Self

Consume self and return the next variant, as per what the current phase is.

pub fn is_emergency(&self) -> bool

Whether the phase is emergency or not.

pub fn is_signed(&self) -> bool

Whether the phase is signed or not.

pub fn is_unsigned(&self) -> bool

Whether the phase is unsigned or not.

pub fn is_off(&self) -> bool

Whether the phase is off or not.

pub fn is_snapshot(&self) -> bool

Whether the phase is snapshot or not.

pub fn is_done(&self) -> bool

Whether the phase is done or not.

pub fn is_export(&self) -> bool

Whether the phase is export or not.

pub fn is_signed_validation(&self) -> bool

Whether the phase is signed validation or not.

pub fn is_signed_validation_opened_now(&self) -> bool

Whether the signed phase is opened now.

pub fn is_unsigned_opened_now(&self) -> bool

Whether the unsigned phase is opened now.

Trait Implementations

impl<T: Config> Clone for Phase<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

where BlockNumberFor<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> Default for Phase<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Config> Encode for Phase<T>

where BlockNumberFor<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> Get<Phase<T>> for GetDone<T>

fn get() -> Phase<T>

Return the current value.

impl<T: Config> Get<Phase<T>> for GetSigned<T>

fn get() -> Phase<T>

Return the current value.

impl<T: Config, Queued: Get<Phase<T>>, NotQueued: Get<Phase<T>>> Get<Phase<T>> for IfSolutionQueuedElse<T, Queued, NotQueued>

fn get() -> Phase<T>

Return the current value.

impl<T> MaxEncodedLen for Phase<T>

where T: Config,

fn max_encoded_len() -> usize

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

impl<T: Config> PartialEq for Phase<T>

fn eq(&self, other: &Self) -> 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 Phase<T>

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

type Identity = Phase<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> Copy for Phase<T>

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

where BlockNumberFor<T>: DecodeWithMemTracking,

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

where BlockNumberFor<T>: Encode,

impl<T: Config> Eq for Phase<T>