Enum Call

pub enum Call<T: Config> {
    enlist {
        collateral: AuthorAsset<T>,
        fortitude: FortitudeWrapper,
    },
    back {
        via: FundingTarget<T>,
        value: AuthorAsset<T>,
        fortitude: FortitudeWrapper,
        precision: PrecisionWrapper,
    },
    refill {
        collateral: AuthorAsset<T>,
        fortitude: FortitudeWrapper,
    },
    confirm {},
    exit {
        from: FundingTarget<T>,
    },
    demit {},
    create_index {
        entries: Vec<(Author<T>, Shares<T>)>,
    },
    create_pool {
        index: IndexDigest<T>,
        commission: Commission<T>,
    },
    transfer_pool {
        pool: PoolDigest<T>,
        to: T::AccountId,
    },
    update_commission {
        index: IndexDigest<T>,
        commission: Commission<T>,
    },
    update_entry_shares {
        index: IndexDigest<T>,
        entry: IndexDigest<T>,
        shares: Shares<T>,
    },
    update_slot_shares {
        pool: PoolDigest<T>,
        slot: PoolDigest<T>,
        shares: Shares<T>,
    },
    force_genesis_config {
        field: ForceGenesisConfig<T>,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

enlist

Enlist the caller as an author by locking the required collateral.

Establishes the caller as an author by placing collateral under the author role commitment.

Requirements

• Provided collateral must be at least MinCollateral.
• Fails if the caller is already enrolled as an author.

Behavior

• Locks the required collateral and associates it with the author role.
• Ensures at least the minimum collateral is maintained.

Execution Controls

• fortitude defines how the collateral is sourced:
  • FortitudeWrapper::Force: Uses the caller’s liquid balance to place the collateral.
  • FortitudeWrapper::Polite: Uses funds already deposited into the commitment reserve (if Config::CommitmentAdapter == pallet_commitment).

Emits: Event::AuthorEnlisted

Fields

collateral: AuthorAsset<T>

fortitude: FortitudeWrapper

back

Provide economic backing support to an author using a supported funding model.

This extrinsic allows the caller to economically support an author by locking assets under the FreezeReason::AuthorFunding commitment domain. Funding directly affects an author’s eligibility, exposure, and election weight.

Funding Models

• Direct: Funds are committed explicitly to a single author.
• Index: Route funds through an index resolving to multiple author digests.
• Pool: Commit funds to a managed pool of authors with commission-based withdrawals.

Guarantees

• Funds are fully locked and cannot be double-used elsewhere.
• Author collateral is never mixed with external funding.
• MinFund and MaxExposure are strictly enforced.
• Local minimum and maximum limits enforced by authors and underlying systems are considered.
• Funding is rejected if the resolved author or digest is invalid.

Execution Controls

• precision defines how strictly the requested amount must be satisfied:
  • [Precision::Exact]: Requires full amount commitment.
  • [Precision::BestEffort]: Allows partial fulfillment where supported.
• force defines how funds are sourced:
  • [Fortitude::Force]: Uses the caller’s liquid balance, enforcing the commitment directly.
  • [Fortitude::Polite]: Uses funds already deposited in the commitment reserve (if Config::CommitmentAdapter == pallet_commitment).

Emits via internal hook: - Event::AuthorFunded if direct author backing - Event::IndexFunded multiple authors via an index - Event::PoolFunded multiple authors via a managed pool

Fields

via: FundingTarget<T>

value: AuthorAsset<T>

fortitude: FortitudeWrapper

precision: PrecisionWrapper

refill

Increase the caller’s collateral by locking additional assets.

Adds to the existing collateral, strengthening the author’s position and ensuring compliance with evolving system requirements such as MinCollateral.

Behavior

• Collateral is added on top of existing locked collateral.

Execution Controls

• fortitude defines how the collateral is sourced:
  • FortitudeWrapper::Force: Uses the caller’s liquid balance to place the additional collateral.
  • FortitudeWrapper::Polite: Uses funds already deposited into the commitment reserve (if Config::CommitmentAdapter == pallet_commitment).

Emits: Event::AuthorCollateralRaised

Fields

collateral: AuthorAsset<T>

fortitude: FortitudeWrapper

confirm

Confirm the caller as an active author after completing probation.

Transitions the author from probation to active status once all probation conditions are satisfied.

Requirements

• Caller must be under probation.
• Probation conditions must be fulfilled.

Notes

• Authors are responsible for completing their probation requirements.
• Activation enables full participation in author duties.

Emits: Event::AuthorStatus via internal hook

exit

Exit an existing backing position towards an author.

Releases the caller’s committed funds (including any applicable rewards or penalties) from a direct, index, or pool-based backing, once the position is eligible for exit.

Behavior

• Exits only the caller’s backing position.
• Author collateral remains unaffected.
• Other backers’ commitments remain intact.

Validation

• Ensures the backing position exists and is withdrawable.
• Resolves the target author from index or pool digests.

Emits:

• Event::AuthorDrawn for direct backing
• Event::IndexDrawn for index-based backing
• Event::PoolDrawn for pool-based backing

Fields

from: FundingTarget<T>

demit

Resign from the author role and exit active participation.

Releases the caller’s collateral while retaining any external backing relationships until funders explicitly exit their positions.

Behavior

• Removes the caller from active author participation.
• Releases all locked collateral back to the caller.
• External funders/backers must withdraw separately via Pallet::exit.
• The author’s digest is reaped only if no active backing remains.

Emits: Event::AuthorResigned

create_index

Create a new funding index over a set of authors.

An index represents a weighted collection of author commitment digests, enabling aggregated funding and proportional exposure.

• Index entries resolve exclusively to author collateral digests.
• Share weights are deterministic and auditable.
• The caller becomes the index owner.

Emits: Event::IndexCreated via deposit event

Fields

entries: Vec<(Author<T>, Shares<T>)>

create_pool

Create a new funding pool backed by an existing index.

Pools enable managed aggregation of funds with an explicit commission applied to rewards earned via the underlying index.

• Pool configuration is uniquely identified by its digest.
• Commission is fixed at creation time, changing commission after creates a new pool with same slots and updated commission.
• The caller becomes the initial pool manager.

Emits: Event::PoolCreated via deposit event

Fields

index: IndexDigest<T>

commission: Commission<T>

transfer_pool

Transfer management ownership of a funding pool.

Updates the pool manager without affecting custody of funds. The pool remains non-custodial, and all underlying funds, slots, and backing relationships remain unchanged.

Requirements

• Callable only by the current pool manager.

Behavior

• Transfers only management control.
• Does not transfer ownership of any pooled funds.

Emits: Event::PoolManager

Fields

pool: PoolDigest<T>

to: T::AccountId

update_commission

Update the commission for a funding pool by creating a new pool instance.

This operation does not mutate the existing pool. Instead, it creates a new pool derived from the given index with the updated commission, assigning the caller as the new pool manager.

Behavior

• A new pool is created with the specified commission.
• The caller becomes the manager of the new pool.
• The new pool starts with no funds or backing.
• The original pool remains unchanged.

Notes

• Pools are non-custodial, and funds are not transferred during this operation.
• This effectively creates a fresh pool configuration with updated parameters.

Emits: Event::PoolCreated

Fields

index: IndexDigest<T>

commission: Commission<T>

update_entry_shares

Derive a new index with updated share weight for a specific entry.

This operation does not mutate the existing index. Instead, it creates a new index configuration where the specified entry is assigned the given shares, while all other entries remain unchanged.

Behavior

• Produces a new index digest reflecting the updated share distribution.
• The original index remains immutable and unchanged.

Notes

• Indexes are immutable once created.
• Any modification to entry shares results in a new index instance.

Emits: Event::IndexCreated

Fields

index: IndexDigest<T>

entry: IndexDigest<T>

shares: Shares<T>

update_slot_shares

Update the share weight of a slot within an existing pool.

Modifies the share allocation of the specified slot in the given pool without altering the pool’s identity or existing commitments.

Requirements

• Caller must be the current pool manager.
• The specified pool and slot must be valid.

Behavior

• Updates the slot’s share weight in place.
• Preserves all existing funds, commitments, and pool configuration.

Notes

• Unlike indexes, pools are mutable and support in-place updates.

Emits: Event::PoolSlotShare

Fields

pool: PoolDigest<T>

slot: PoolDigest<T>

shares: Shares<T>

force_genesis_config

Force-update a selected genesis configuration parameter.

Origin: Root only.

This extrinsic allows privileged modification of runtime parameters that were originally defined at genesis.

• ProbationPeriod - Updates the number of blocks authors must remain in probation.
• ReduceProbationBy - Updates how much probation is reduced on good behavior.
• IncreaseProbationBy - Updates how much probation is increased on misbehavior.
• RewardsBuffer - Updates the delay (in blocks) before rewards are finalized.
• PenaltiesBuffer - Updates the delay (in blocks) before penalties are enforced.
• MaxElected - Updates the maximum number of authors that can be elected.
• MinElected - Updates the minimum number of authors required for a valid election.
• EnforceMaxElected - Toggles strict enforcement of the MaxElected limit.
• MinFund - Updates the minimum funding required per backing operation.
• MaxExposure - Updates the maximum allowed exposure per funding operation.
• MinCollateral - Updates the minimum collateral required for authors.

The call enforces consistency constraints where applicable:

• Values that must be non-zero will fail with Error::NonZeroConfigRequired.
• Fails with Error::MinGreaterThanMax if:
  • MinElected > MaxElected, or
  • MinFund > MaxExposure, or
  • MaxElected < MinElected, or
  • MaxExposure < MinFund.

This call directly overwrites storage and emits an event containing the updated configuration variant.

Fields

field: ForceGenesisConfig<T>

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_enlist( collateral: AuthorAsset<T>, fortitude: FortitudeWrapper, ) -> Self

Create a call with the variant enlist.

pub fn new_call_variant_back( via: FundingTarget<T>, value: AuthorAsset<T>, fortitude: FortitudeWrapper, precision: PrecisionWrapper, ) -> Self

Create a call with the variant back.

pub fn new_call_variant_refill( collateral: AuthorAsset<T>, fortitude: FortitudeWrapper, ) -> Self

Create a call with the variant refill.

pub fn new_call_variant_confirm() -> Self

Create a call with the variant confirm.

pub fn new_call_variant_exit(from: FundingTarget<T>) -> Self

Create a call with the variant exit.

pub fn new_call_variant_demit() -> Self

Create a call with the variant demit.

pub fn new_call_variant_create_index( entries: Vec<(Author<T>, Shares<T>)>, ) -> Self

Create a call with the variant create_index.

pub fn new_call_variant_create_pool( index: IndexDigest<T>, commission: Commission<T>, ) -> Self

Create a call with the variant create_pool.

pub fn new_call_variant_transfer_pool( pool: PoolDigest<T>, to: T::AccountId, ) -> Self

Create a call with the variant transfer_pool.

pub fn new_call_variant_update_commission( index: IndexDigest<T>, commission: Commission<T>, ) -> Self

Create a call with the variant update_commission.

pub fn new_call_variant_update_entry_shares( index: IndexDigest<T>, entry: IndexDigest<T>, shares: Shares<T>, ) -> Self

Create a call with the variant update_entry_shares.

pub fn new_call_variant_update_slot_shares( pool: PoolDigest<T>, slot: PoolDigest<T>, shares: Shares<T>, ) -> Self

Create a call with the variant update_slot_shares.

pub fn new_call_variant_force_genesis_config( field: ForceGenesisConfig<T>, ) -> Self

Create a call with the variant force_genesis_config.

Trait Implementations

impl<T: Config> CheckIfFeeless for Call<T>

type Origin = <T as Config>::RuntimeOrigin

The Origin type of the runtime.

fn is_feeless(&self, origin: &Self::Origin) -> bool

Checks if the dispatchable satisfies the feeless condition as defined by #[pallet::feeless_if]

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T: Config> Decode for Call<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: Config> Encode for Call<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> GetCallIndex for Call<T>

fn get_call_index(&self) -> u8

Return the index of this Call.

fn get_call_indices() -> &'static [u8]

Return all call indices in the same order as [GetCallName].

impl<T: Config> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

Return the function name of the Call.

fn get_call_names() -> &'static [&'static str]

Return all function names in the same order as [GetCallIndex].

impl<T: Config> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config> PartialEq for Call<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 Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, AuthorAsset<T>: TypeInfo + 'static, FundingTarget<T>: TypeInfo + 'static, Vec<(Author<T>, Shares<T>)>: TypeInfo + 'static, IndexDigest<T>: TypeInfo + 'static, Commission<T>: TypeInfo + 'static, PoolDigest<T>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, Shares<T>: TypeInfo + 'static, ForceGenesisConfig<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = Call<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> UnfilteredDispatchable for Call<T>

type RuntimeOrigin = <T as Config>::RuntimeOrigin

The origin type of the runtime, (i.e. frame_system::Config::RuntimeOrigin).

fn dispatch_bypass_filter( self, origin: Self::RuntimeOrigin, ) -> DispatchResultWithPostInfo

Dispatch this call but do not check the filter in origin.

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

where AuthorAsset<T>: DecodeWithMemTracking, FundingTarget<T>: DecodeWithMemTracking, Vec<(Author<T>, Shares<T>)>: DecodeWithMemTracking, IndexDigest<T>: DecodeWithMemTracking, Commission<T>: DecodeWithMemTracking, PoolDigest<T>: DecodeWithMemTracking, T::AccountId: DecodeWithMemTracking, Shares<T>: DecodeWithMemTracking, ForceGenesisConfig<T>: DecodeWithMemTracking,

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

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