Enum Error

pub enum Error<T, I = ()> {
    DigestNotFoundToDetermine,
    InsufficientFunds,
    CommitAlreadyExists,
    CannotGenerateDigest,
    MarkerCommitNotAllowed,
    CommitNotFound,
    DigestNotFound,
    IndexNotFound,
    EntryOfIndexNotFound,
    IndexDigestTaken,
    DigestHasFunds,
    IndexHasFunds,
    PoolNotFound,
    SlotOfPoolNotFound,
    PoolManagerNotFound,
    PoolDigestTaken,
    PoolHasFunds,
    DigestVariantBalanceNotFound,
    MaxAssetIssued,
    MaxAssetReaped,
    ShareCannotBeZero,
    CapitalCannotBeZero,
    ShareGreaterThanCapital,
    MintingMoreThanIssued,
    BurningMoreThanReapable,
    ExpectsHoldWithdrawal,
    ReserveLiquidOverflow,
    ExpectsFreezeAndHoldWithdrawal,
    InvalidDigestModel,
    VariantsExhausted,
    TooSmallShareValue,
    DepositDeriveOverflowed,
    FactorGreaterThanOne,
    MaxIndexCapacityReached,
    CommitNotFoundForEntry,
    CommitNotFoundForSlot,
    CommitNotFoundForPool,
    DepositAccumulationExhausted,
    EntryDigestNotFound,
    WithdrawAccumulationExhausted,
    CommitsAccumulationExhausted,
    ReleasePoolToRecover,
    EmptySlotsNotAllowed,
    CapitalUnderflowed,
    CapitalOverflowed,
    MaxSlotsReached,
    SlotDigestNotFound,
    MaxCommitsReached,
    MaxEntriesReached,
    CommitsNotFoundForReason,
    IndexBalanceUnderflow,
    InvalidCommitVariantIndex,
    ZeroMaxCommits,
    TriedCreatingHaltedIndexes,
    EmptyEntriesNotAllowed,
    EmptyCommitsNotAllowed,
    DuplicateEntry,
    DuplicateSlot,
    CommitConstructionFailed,
    EntryCommitNotFound,
    CorruptedPlugin,
    DerivedLessThanZeroValue,
    WithdrawalOverflow,
    CommissionOverflow,
    PoolUnsupported,
    MintingOffLimits,
    ReapingOffLimits,
    PlacingOffLimits,
    RaisingOffLimits,
    // some variants omitted
}

Commitment Pallet Errors

Variants

DigestNotFoundToDetermine

Digest not found in the system. Cannot determine whether it is a direct digest, index, or pool.

InsufficientFunds

Insufficient funds for the requested operation.

Consider forcing the operation or reducing the given asset value.

CommitAlreadyExists

The proprietor already holds a commitment for the reason.

Only a single commit should exist for a reason. Utilize indexes and pools in case of distributing multiple commitments.

CannotGenerateDigest

Failed to generate a digest for a given source or index/pool structure.

MarkerCommitNotAllowed

A commitment with zero value is invalid.

Commitments are economic in nature and must not be used as zero-value markers.

CommitNotFound

The proprietor’s commit was not found in the system.

DigestNotFound

The specified direct-digest was not found in the system.

IndexNotFound

The specified index digest was not found in the system.

EntryOfIndexNotFound

The specified entry digest is not found in the index.

IndexDigestTaken

The specified index digest already exists for the given reason.

DigestHasFunds

Attempted to remove/reap a direct-digest that still holds funds.

IndexHasFunds

Attempted to remove/reap an index that still holds funds.

PoolNotFound

The specified pool digest was not found in the system.

SlotOfPoolNotFound

The specified slot digest is not found in the pool.

PoolManagerNotFound

The Manager for the specified Pool is not found. A Pool is expected to have a manager at all times.

PoolDigestTaken

The specified pool digest already exists for the given reason.

PoolHasFunds

Attempted to remove/reap a pool that still holds funds.

DigestVariantBalanceNotFound

The direct-digest balance specialized for the given commit-variant (position) is not initialized or found to be.

It can only be initialized during deposit operations. Not while being queried.

MaxAssetIssued

Cannot include more asset value for issuing as the total issue balance exhausted.

• For non-issuance assets: migrate to a larger scalar type immediately.
• For issuance assets: conduct an internal audit on the asset (unexpected behavior).

MaxAssetReaped

Cannot include more asset value for reaping as the total reapable balance exhausted.

• For non-issuance assets: migrate to a larger scalar type immediately.
• For issuance assets: conduct an internal audit on the asset (unexpected behavior).

ShareCannotBeZero

Shares given for an index’s entry or a pool’s slot cannot be zero. Marker entries or slots are invalid in the system.

CapitalCannotBeZero

Capital cannot be zero when creating an index or pool.

Correct behavior:

• Index/Pool must have sum(shares) == capital.
• Entries/Slots must not have empty shares.

ShareGreaterThanCapital

Share value exceeded capital when creating an index or pool.

Correct behavior: every entry/slot must satisfy share <= capital.

MintingMoreThanIssued

Asset Issued and Minting to the underlying fungible system detected inconsistency.

BurningMoreThanReapable

Asset To Reap and Burning to the underlying fungible system detected inconsistency.

ExpectsHoldWithdrawal

Indicates that the operation expects the proprietor’s existing reserves (held funds) to be released in order to proceed, typically to be re-deposited under the commitment hold reason (PrepareForCommit).

If this is not possible, the operation may attempt to proceed by forcing withdrawal from liquid funds, potentially risking account closure if enforced by the asset provider or best-effort methods.

ReserveLiquidOverflow

Asset units overflown when commit-reserve balance is added with liquidly held funds.

• For non-issuance assets: migrate to a larger scalar type immediately.
• For issuance assets: conduct an internal audit on the asset (unexpected behavior).

ExpectsFreezeAndHoldWithdrawal

Indicates that the operation expects the proprietor’s existing reserves (held funds) and freezes (locked funds) to be released in order to proceed, typically to be re-deposited under the commitment hold reason (PrepareForCommit).

Since, the operation cannot attempt to proceed by forcing withdrawal from just liquid funds, as its insufficient.

Try to reduce provided asset amount or do operation based on best-effort possible only.

InvalidDigestModel

The Model of Digest constructed is invalid, since its possibly a compile time marker.

VariantsExhausted

Digest commit-variant (positional) balances are exhausted or at maximum capacity.

This reveals that the Config::Position’s trait PositionIndex is implemented not as-per its defined invariants.

TooSmallShareValue

Share value is too small (underflow) to produce a valid factor when calculating share/capital.

Possible resolutions:

• Increase the fixed-point precision of Bias in future upgrades.
• Increase the index entry or pool slot’s share value and retry.

DepositDeriveOverflowed

Deposit derivation overflowed during index or pool deposit operation.

Occurs when an excessively high share/capital ratio, multiplied by a balance value, overflows the scalar.

FactorGreaterThanOne

share/capital ratio produced a factor greater than 1.

This results in errors which may indicate invariants are broken.

• sum(shares) <= capital or,
• current_share > capital

MaxIndexCapacityReached

Index total balance (deposits-only) has reached its maximum top-level capacity.

• For non-issuance assets: migrate to a larger scalar type immediately.
• For issuance assets: conduct an internal audit on the asset (unexpected behavior).

CommitNotFoundForEntry

Proprietor doesn’t hold commits for the specified entry of an index.

Indicates that the prorprietor haven’t committed to the index at all.

CommitNotFoundForSlot

Proprietor doesn’t hold commits for the specified slot of a pool.

Indicates that the prorprietor haven’t committed to the pool at all.

CommitNotFoundForPool

Proprietor doesn’t hold commits for the specified pool.

DepositAccumulationExhausted

Accumulating total deposit for direct and indirect digests (index/pools) has overflowed the provided asset type.

• For non-issuance assets: migrate to a larger scalar type immediately.
• For issuance assets: conduct an internal audit on the asset (unexpected behavior).

EntryDigestNotFound

The digest for the specified entry of index was not found in the list of digests.

The digest list represents the underlying direct digests for which commitments have been made.

WithdrawAccumulationExhausted

Accumulating total withdrawal for direct or indirect digests (pool/index) has overflowed the provided asset type.

• For non-issuance assets: migrate to a larger scalar type immediately.
• For issuance assets: conduct an internal audit on the asset (unexpected behavior).

CommitsAccumulationExhausted

Accumulating total real-time values of all commit instances has overflowed the provided asset type.

• For non-issuance assets: migrate to a larger scalar type immediately.
• For issuance assets: conduct an internal audit on the asset (unexpected behavior).

ReleasePoolToRecover

Indicates that a pool was recovered without being released i.e., empty.

EmptySlotsNotAllowed

The specified pool requires atleast a single slot, with valid shares to carry the operation.

CapitalUnderflowed

Capital shares underflowed during index or pool creation/modification.

CapitalOverflowed

Capital shares overflowed during index or pool creation/modification.

MaxSlotsReached

Maximum number of slots in a pool is reached.

SlotDigestNotFound

The digest for the specified slot of pool was not found in the list of digests.

The digest list represents the underlying direct digests for which commitments have been made.

MaxCommitsReached

Max Commits per reason (as per commitment invariant for a single digest model) is exhausted.

Try resolving and committing a new value instead to the same digest model.

MaxEntriesReached

Maximum number of entries in an index is reached.

CommitsNotFoundForReason

Reason exists (as its compile-time proved) but contains no commitments.

IndexBalanceUnderflow

Index logic is broken, since withdrawing index balance is only for higher level queries and deposits (principal) is only withdrawn.

InvalidCommitVariantIndex

There exists an invalid commit-variant Config::Position via invalid trait implementation of PositionIndex.

Indicates the position cannot be derived from the positional index or that the index doesn’t pertain to the actual position.

ZeroMaxCommits

This pallet instance’s maximum commitment per proprietor configuration is set at zero, effectively restricts the commitment-pallet’s operations.

Require Config::MaxCommits to be set to more than zero to operate.

TriedCreatingHaltedIndexes

This pallet instance’s index and pool support is halted via setting Config::MaxIndexEntries to zero and tried attempting to create an index (and in future pools via indexes).

If indexes and pools are required Config::MaxIndexEntries should be set to more than zero.

EmptyEntriesNotAllowed

Attempted to create index via empty entries. Indexes require valid entries, with non-zero share values.

It is to note that pools are created via existing indexes and pool slots are mutated via valid individual entries.

EmptyCommitsNotAllowed

A proprietor’s commit is found to be empty without any commit-instance which is an invalid state.

DuplicateEntry

Attempted to insert a duplicate entry into an index.

DuplicateSlot

Attempted to insert a duplicate slot into a pool.

CommitConstructionFailed

For reasons unknown, the commit-instance construction has failed.

EntryCommitNotFound

The required entry’s commit for proprietor is not found while raising commit.

CorruptedPlugin

The balance plugin was corrupted

DerivedLessThanZeroValue

During Division Scaling the value underflowed, which is fallible only if the accuracy (denominator) is invalid.

WithdrawalOverflow

Withdraw derivation overflowed during index or pool deposit operation.

Occurs when an excessively high share/capital ratio, multiplied by a balance value, overflows the scalar.

CommissionOverflow

Derived Commission Amount Overflowed the Scalar Asset Type.

PoolUnsupported

Pools are unsupported when the underlying balance plugin cannot guarantee precision-exact and forceful (unbounded) operations.

Pools maintain their own top-level balance and rely on exact value propagation and forced execution to remain consistent. If the plugin enforces limits even under forced execution, these requirements cannot be satisfied, making pool semantics invalid.

MintingOffLimits

Direct Digest Minting exceeded allowed limits by the underlying Lazy Balance Plugin Family for the current operation.

ReapingOffLimits

Direct Digest Reaping (Burning) exceeded allowed limits by the underlying Lazy Balance Plugin Family for the current operation.

PlacingOffLimits

Placing a new commitment has exceeded allowed deposit limits by the underlying Lazy Balance Plugin Family for the current operation.

RaisingOffLimits

Increasing (raising) an existing commitment has exceeded allowed raising (deposit) limits by the underlying Lazy Balance Plugin Family for the current operation.

Trait Implementations

impl<T: Config<I>, I: 'static> Debug for Error<T, I>

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

Formats the value using the given formatter.

impl<T, I> Decode for Error<T, I>

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

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

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

Converts to this type from the input type.

impl<T: Config<I>, I: 'static> From<Error<T, I>> for DispatchError

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

Converts to this type from the input type.

impl<T, I> PalletError for Error<T, I>

const MAX_ENCODED_SIZE: usize = 1usize

The maximum encoded size for the implementing type.

impl<T, I> TypeInfo for Error<T, I>

where PhantomData<(T, I)>: TypeInfo + 'static, T: 'static, I: 'static,

type Identity = Error<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T, I> DecodeWithMemTracking for Error<T, I>

impl<T, I> EncodeLike for Error<T, I>