Enum Error

pub enum Error<T> {
    AffidavitAuthorNotFound,
    BlockPointsNotFound,
    BlockPointsExhausted,
    AffidavitNotFound,
    AffidavitsNotAllowed,
    NotAffidavitPeriod,
    AffidavitPeriodEnded,
    NotElectionPeriod,
    InvalidAffidavitPeriod,
    ElectionPeriodEnded,
    AuthorNotAffidavitOwner,
    SessionIdQueryFailed,
    ValidatorCannotChill,
    CandidateCannotChill,
    ElectedCannotChill,
    AffidavitKeyExists,
    NextAffidavitKeyExists,
    CannotSignAffidavitTxPayload,
    CannotSignValidateTxPayload,
    ExpectedToHoldActiveAffidavitKey,
    ExpectedToNotHoldActiveAffidavitKey,
    ExpectedToHoldNextAffidavitKey,
    ExpectedToHoldFinalizedNextAffidavitKey,
    OCWStorageDecisionHalt,
    CannotSubmitAffidavitTx,
    FailedToDeclareAffidavit,
    YetToElectAuthors,
    CannotSignElectionTxPayload,
    CannotSubmitElectionTx,
    ExtrinsicFailedToElectAuthors,
    SetNewAffidavitKeyFailed,
    SetNextAffidavitKeyFailed,
    ExpectedActiveAffidavitKeyPairNotFound,
    ExpectedNextAffidavitKeyPairNotFound,
    ValidationStopped,
    ActivelyValidating,
    ActivelyContestingElection,
    ActivelyWarmingForValidation,
    CannotDetermineAuthorActiveDuty,
    ActiveAfdtKeyNotYetFinalized,
    ActiveAfdtKeyFinalizedValueDecodeFail,
    ActiveAfdtKeySpeculativeHashDecodeFail,
    ActiveAfdtKeyFinalizedValueConcurrentMutation,
    ActiveAfdtKeySpeculativeHashConcurrentMutation,
    ActiveAfdtKeyFinalizedHangingValue,
    ActiveAfdtKeySpeculativeHangingHash,
    NextAfdtKeyNotYetFinalized,
    NextAfdtKeyFinalizedValueDecodeFail,
    NextAfdtKeySpeculativeHashDecodeFail,
    NextAfdtKeyFinalizedValueConcurrentMutation,
    NextAfdtKeySpeculativeHashConcurrentMutation,
    NextAfdtKeyFinalizedHangingValue,
    NextAfdtKeySpeculativeHangingHash,
    AffidavitTxAwaitingStatus,
    ProceedingToAffidavitSubmission,
    DeclareDuringNextAffidavitSession,
    DeclaredBeforeAffidavitPeriod,
    InvalidRotatedAffidavitKey,
    BlockAuthorNotFound,
    TriedElectingByNonBlockAuthor,
    AffidavitKeyForDeclaration,
    ValueCannotBeZero,
    InitAffidavitKeyRoutineSuccess,
    TryElectionRoutineSuccess,
    DeclarAffidavitRoutineSuccess,
    RotateAffidavitKeyRoutineSuccess,
    AuthorAlreadyChilling,
    ElectedButCannotReveal,
    DeclaredAffidavitNotFound,
    NotABlockAuthor,
    AfdtPublicKeyNotFound,
    AffidavitKeyPairNotFound,
    UnableToRevealElected,
    MaxOCWForksAttained,
    OCWForksNotEnabled,
    OCWForksInconsistent,
    // some variants omitted
}

The Error enum of this pallet.

Variants

AffidavitAuthorNotFound

The requested affidavit-ready author was not found.

This may happen if:

• The author has not declared readiness for validation via
  validate extrinsic
• The author has not declared affidavit keys for the upcoming session
• The provided affidavit key is invalid

BlockPointsNotFound

Block production points for the specified author were not found.

BlockPointsExhausted

The author has exhausted the maximum allowed block production points for the current session.

Consider scaling the points type or constraining accumulation according to block production frequency.

AffidavitNotFound

The specified author has not submitted an affidavit for the upcoming session.

AffidavitsNotAllowed

Affidavit submissions are not enabled by configuration.

NotAffidavitPeriod

The affidavit submission window for the upcoming session has not started yet in the current session.

AffidavitPeriodEnded

The affidavit submission window for the upcoming session has ended.

The author must wait for the next session’s affidavit period.

NotElectionPeriod

The election period for the upcoming session has not started yet in the current session.

InvalidAffidavitPeriod

Invalid affidavit configuration.

AffidavitBeginsAt must be less than or equal to AffidavitEndsAt.

ElectionPeriodEnded

The election period for the upcoming session has ended.

The author must wait for the next session’s election period.

AuthorNotAffidavitOwner

The author has not registered ownership of the given affidavit key.

The key itself may be valid, but it does not belong to the author.

SessionIdQueryFailed

Failed to query the session ID for the author.

This usually indicates that the author does not hold an active author role.

ValidatorCannotChill

The author cannot chill immediately because they are an elected validator in the current session.

CandidateCannotChill

The author cannot chill immediately because they have submitted an affidavit and are a candidate for election.

ElectedCannotChill

The author cannot chill immediately because they are elected for the upcoming session.

AffidavitKeyExists

An active affidavit key already exists in the node’s local keystore.

No new key generation is required. If the node has a valid author role, it may already be ready for validate extrinsic.

Or if the author is ready to declare affidavit he is eligible to do so.

NextAffidavitKeyExists

A next-session affidavit key already exists in the node’s local keystore.

An affidavit declaration is ready to be posted and the key is ready for rotation.

CannotSignAffidavitTxPayload

Failed to sign the affidavit submission extrinsic payload using the active affidavit key.

CannotSignValidateTxPayload

Failed to construct and sign validate payload using the active affidavit key.

ExpectedToHoldActiveAffidavitKey

The node is expected to hold an active affidavit key, but none was found.

This indicates an inconsistency between earlier logic and current storage. The OCW will retry, but persistent failure suggests storage corruption.

ExpectedToNotHoldActiveAffidavitKey

The node is expected to not hold a active affidavit key in offchain storage, but it is available.

This indicates an inconsistency between earlier logic and current storage. The OCW will retry, but persistent failure suggests storage corruption.

ExpectedToHoldNextAffidavitKey

The node is expected to hold the next affidavit key during the key-rotation lifecycle, but it is missing.

This indicates an inconsistency between earlier logic and current storage. The OCW will retry, but persistent failure suggests storage corruption.

ExpectedToHoldFinalizedNextAffidavitKey

The node is expected to hold a finalized next affidavit key in offchain storage, but it is missing.

This indicates an inconsistency between earlier logic and current storage. The OCW will retry, but persistent failure suggests storage corruption.

OCWStorageDecisionHalt

An offchain storage operation failed.

The OCW halts further decisions for safety. Thus, re-runs in next block execution.

CannotSubmitAffidavitTx

The offchain worker failed to submit the affidavit extrinsic for unknown reasons.

FailedToDeclareAffidavit

Extrinsic submission for declaring an affidavit failed.

YetToElectAuthors

The election period for the upcoming session has not started yet.

CannotSignElectionTxPayload

Failed to sign the election extrinsic payload using the very recently rotated affidavit key.

Subsequent OCW executions at next block shall attempt again.

CannotSubmitElectionTx

The offchain worker failed to submit the election extrinsic for unknown reasons.

Subsequent OCW executions at next block shall attempt again.

ExtrinsicFailedToElectAuthors

Extrinsic submission for electing authors failed.

Subsequent OCW executions at next block shall attempt again.

SetNewAffidavitKeyFailed

A new affidavit key was generated but failed to persist locally.

The OCW will attempt another affidavit submission with a new key.

Persistent failure indicates storage corruption.

SetNextAffidavitKeyFailed

A new affidavit key for rotation and promotion as active affidavit key was generated but failed to persist locally.

The OCW will attempt another affidavit key-rotation with a new key.

Persistent failure indicates storage corruption.

ExpectedActiveAffidavitKeyPairNotFound

The active affidavit key is expected in the local keystore but could not be found.

Recovery requires regenerating the key under the configured KeyTypeId or chilling and restarting validation.

ExpectedNextAffidavitKeyPairNotFound

The rotated next affidavit key is expected in the local keystore but could not be found.

Recovery requires regenerating the key under the configured KeyTypeId or chilling and restarting validation.

ValidationStopped

Validation has been stopped due to affidavit key rotation failure, storage corruption, or failed submissions.

Manual re-validation via validate extrinsic is required.

ActivelyValidating

The author is actively validating in the current session.

The chill extrinsic is blocked until validation completes or the session ends.

ActivelyContestingElection

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

The author may chill if allowed or wait until the election concludes to check assigned duty.

ActivelyWarmingForValidation

The author has been elected for the upcoming session and is preparing for validation duties.

The chill extrinsic is blocked until duties complete.

CannotDetermineAuthorActiveDuty

The author is detected as active, but the specific duty cannot be determined due to inconsistent state.

The chill extrinsic may be attempted to resolve the state.

ActiveAfdtKeyNotYetFinalized

Offchain storage Active Affidavit Key is not yet finalized.

The key exists optimistically in fork-aware storage, but the block containing the finalized value may still be subject to re-org. Until finalized, speculative forks may observe different values.

Until it is finalized subsequent OCWs may result in this state.

ActiveAfdtKeyFinalizedValueDecodeFail

Failed to decode the finalized Active Affidavit Key public key value from persistent offchain storage.

Persistent failure indicates either storage corruption or a type mismatch. Manual intervention may be required. Clearing both fork-aware and persistent offchain storage allows OCWs to reinitialize the key lifecycle.

ActiveAfdtKeySpeculativeHashDecodeFail

Failed to decode the speculative hash of the Active Affidavit Key public key from fork-aware offchain storage.

This hash is used to reference the actual value stored in persistent offchain storage. Persistent failure indicates corruption or decoding inconsistencies. Clearing both fork-aware and persistent storage may resolve it.

ActiveAfdtKeyFinalizedValueConcurrentMutation

Concurrent mutation detected while accessing the finalized Active Affidavit Key public key value.

The operation will be retried by the OCW. Persistent failure indicates a potential deadlock or storage corruption. Clearing both fork-aware and persistent offchain storage may be required.

ActiveAfdtKeySpeculativeHashConcurrentMutation

Concurrent mutation detected while accessing the speculative hash of the Active Affidavit Key public key.

The hash resides in fork-aware storage while the actual value exists in persistent storage. The operation will be retried by the OCW. Persistent failure indicates storage corruption or a deadlock condition.

ActiveAfdtKeyFinalizedHangingValue

A finalized Active Affidavit Key public key value exists in persistent offchain storage without a corresponding fork-aware hash.

This results in a hanging value with no canonical reference. The persistent value will be cleared automatically. Any remaining fork-aware entries may also become hanging and will be cleaned on access.

ActiveAfdtKeySpeculativeHangingHash

A speculative fork-aware hash for the Active Affidavit Key exists without a corresponding persistent public key value.

Since the actual value cannot be recovered, the hanging speculative hash will be cleared automatically.

NextAfdtKeyNotYetFinalized

Offchain storage Next Affidavit Key is not yet finalized.

The key exists optimistically in fork-aware storage, but the block containing the finalized value may still be subject to re-org. Until finalized, speculative forks may observe different values.

Until it is finalized subsequent OCWs may result in this state.

NextAfdtKeyFinalizedValueDecodeFail

Failed to decode the finalized Next Affidavit Key public key value from persistent offchain storage.

Persistent failure indicates either storage corruption or a type mismatch. Manual intervention may be required. Clearing both fork-aware and persistent offchain storage allows OCWs to reinitialize the key lifecycle.

NextAfdtKeySpeculativeHashDecodeFail

Failed to decode the speculative hash of the Next Affidavit Key public key from fork-aware offchain storage.

This hash is used to reference the actual value stored in persistent offchain storage. Persistent failure indicates corruption or decoding inconsistencies. Clearing both fork-aware and persistent storage may resolve it.

NextAfdtKeyFinalizedValueConcurrentMutation

Concurrent mutation detected while accessing the finalized Next Affidavit Key public key value.

The operation will be retried by the OCW. Persistent failure indicates a potential deadlock or storage corruption. Clearing both fork-aware and persistent offchain storage may be required.

NextAfdtKeySpeculativeHashConcurrentMutation

Concurrent mutation detected while accessing the speculative hash of the Next Affidavit Key public key.

The hash resides in fork-aware storage while the actual value exists in persistent storage. The operation will be retried by the OCW. Persistent failure indicates storage corruption or a deadlock condition.

NextAfdtKeyFinalizedHangingValue

A finalized Next Affidavit Key public key value exists in persistent offchain storage without a corresponding fork-aware hash.

This results in a hanging value with no canonical reference. The persistent value will be cleared automatically. Any remaining fork-aware entries may also become hanging and will be cleaned on access.

NextAfdtKeySpeculativeHangingHash

A speculative fork-aware hash for the Next Affidavit Key exists without a corresponding persistent public key value.

Since the actual value cannot be recovered, the hanging speculative hash will be cleared automatically.

AffidavitTxAwaitingStatus

The affidavit submission extrinsic has been sent by the OCW and is awaiting on-chain state confirmation and key rotation.

ProceedingToAffidavitSubmission

Not an error.

Indicates that a neccessary election attempt was made early, so the OCW will proceed with affidavit submission instead.

DeclareDuringNextAffidavitSession

Affidavit submission was declined because the author has already rotated keys for the next session.

The author must wait for the next affidavit window.

DeclaredBeforeAffidavitPeriod

An affidavit is declared and the key is rotated before the current affidavit submission period itself.

InvalidRotatedAffidavitKey

The given affidavit key is not the recently rotated affidavit key, from the recently declared affidavit.

This implies the author have declared their affidavit and have rotated a new key for the the election after the upcoming election.

BlockAuthorNotFound

The requested block author of this very current block is not available.

TriedElectingByNonBlockAuthor

An election is attempted by a non-block author. Elections can only be processed by block-authors only in their authored blocks only.

AffidavitKeyForDeclaration

The active affidavit key is utilized for affidavit-declaration and not for processing election.

Election can only be processed by recently rotated affidavit key, which poses for the next affidavit-declaration session also.

All these can be valid only if the author started validating, else its a dormant affidavit key

ValueCannotBeZero

The provided value must be non-zero.

Returned when a parameter or input is required to be strictly greater than zero.

InitAffidavitKeyRoutineSuccess

Internal success signal for the affidavit key initialization routine.

Used to indicate successful execution of the initialization flow.

TryElectionRoutineSuccess

Internal success signal for the election execution routine.

Indicates that the election process completed successfully.

DeclarAffidavitRoutineSuccess

Internal success signal for the affidavit declaration routine.

Indicates that the affidavit has been successfully declared.

RotateAffidavitKeyRoutineSuccess

Internal success signal for the affidavit key rotation routine.

Indicates that the key rotation process completed successfully.

AuthorAlreadyChilling

The author is already in a chilled (inactive) state.

Returned when attempting to chill an author that is already inactive.

ElectedButCannotReveal

Authors are successfully elected, but cannot be revealed for some reasons unknown.

DeclaredAffidavitNotFound

Author declared an affidavit, but it could not be retrieved for reasons unknown.

NotABlockAuthor

The caller is not the current block author.

Returned when an operation requires block authorship, but the caller does not match the current block author.

AfdtPublicKeyNotFound

No public key matching the given affidavit identifier was found in the node-local keystore.

The key may have been lost, never generated on this node, or the identifier does not correspond to any locally held key pair.

AffidavitKeyPairNotFound

No affidavit key is registered for the author in any relevant future session scope (next session or next affidavit session).

The author has not called Pallet::validate or has already chilled.

UnableToRevealElected

The election result could not be revealed.

No election has been executed for the current session, or the underlying election manager returned no result.

MaxOCWForksAttained

The fork graph has reached the maximum number of concurrent forks.

No new sibling branch can be created until an existing fork is resolved or pruned. This indicates an unusually high degree of chain instability relative to the configured MAX_FORKS constant.

OCWForksNotEnabled

Fork-aware offchain storage was accessed before the fork graph was initialized via ForksHandler::start.

OCWForksInconsistent

The fork graph is in an inconsistent state.

An internal invariant was violated, such as a branch entry that cannot be decoded or a divider that references a non-existent branch. Persistent failure indicates offchain storage corruption.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T> Decode for Error<T>

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> Encode for Error<T>

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> From<Error<T>> for &'static str

fn from(err: Error<T>) -> &'static str

Converts to this type from the input type.

impl<T: Config> From<Error<T>> for DispatchError

fn from(err: Error<T>) -> Self

Converts to this type from the input type.

impl<T> PalletError for Error<T>

const MAX_ENCODED_SIZE: usize = 1usize

The maximum encoded size for the implementing type.

impl<T> TypeInfo for Error<T>

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

type Identity = Error<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T> DecodeWithMemTracking for Error<T>

impl<T> EncodeLike for Error<T>