Enum Call

pub enum Call<T: Config> {
    configure {
        config: ConfigRecordOf<T>,
    },
    reserve {
        workload: Schedule,
    },
    unreserve {
        item_index: u32,
    },
    set_lease {
        task: TaskId,
        until: Timeslice,
    },
    start_sales {
        end_price: BalanceOf<T>,
        extra_cores: CoreIndex,
    },
    purchase {
        price_limit: BalanceOf<T>,
    },
    renew {
        core: CoreIndex,
    },
    transfer {
        region_id: RegionId,
        new_owner: T::AccountId,
    },
    partition {
        region_id: RegionId,
        pivot: Timeslice,
    },
    interlace {
        region_id: RegionId,
        pivot: CoreMask,
    },
    assign {
        region_id: RegionId,
        task: TaskId,
        finality: Finality,
    },
    pool {
        region_id: RegionId,
        payee: T::AccountId,
        finality: Finality,
    },
    claim_revenue {
        region_id: RegionId,
        max_timeslices: Timeslice,
    },
    purchase_credit {
        amount: BalanceOf<T>,
        beneficiary: RelayAccountIdOf<T>,
    },
    drop_region {
        region_id: RegionId,
    },
    drop_contribution {
        region_id: RegionId,
    },
    drop_history {
        when: Timeslice,
    },
    drop_renewal {
        core: CoreIndex,
        when: Timeslice,
    },
    request_core_count {
        core_count: CoreIndex,
    },
    notify_core_count {
        core_count: CoreIndex,
    },
    notify_revenue {
        revenue: OnDemandRevenueRecordOf<T>,
    },
    enable_auto_renew {
        core: CoreIndex,
        task: TaskId,
        workload_end_hint: Option<Timeslice>,
    },
    disable_auto_renew {
        core: CoreIndex,
        task: TaskId,
    },
    force_reserve {
        workload: Schedule,
        core: CoreIndex,
    },
    remove_lease {
        task: TaskId,
    },
    remove_assignment {
        region_id: RegionId,
    },
    swap_leases {
        id: TaskId,
        other: TaskId,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

configure

Configure the pallet.

• origin: Must be Root or pass AdminOrigin.
• config: The configuration for this pallet.

Fields

config: ConfigRecordOf<T>

reserve

Reserve a core for a workload.

The workload will be given a reservation, but two sale period boundaries must pass before the core is actually assigned.

• origin: Must be Root or pass AdminOrigin.
• workload: The workload which should be permanently placed on a core.

Fields

workload: Schedule

unreserve

Cancel a reservation for a workload.

• origin: Must be Root or pass AdminOrigin.
• item_index: The index of the reservation. Usually this will also be the index of the core on which the reservation has been scheduled. However, it is possible that if other cores are reserved or unreserved in the same sale rotation that they won’t correspond, so it’s better to look up the core properly in the Reservations storage.

Fields

item_index: u32

set_lease

Reserve a core for a single task workload for a limited period.

In the interlude and sale period where Bulk Coretime is sold for the period immediately after until, then the same workload may be renewed.

• origin: Must be Root or pass AdminOrigin.
• task: The workload which should be placed on a core.
• until: The timeslice now earlier than which task should be placed as a workload on a core.

Fields

task: TaskId

until: Timeslice

start_sales

Begin the Bulk Coretime sales rotation.

• origin: Must be Root or pass AdminOrigin.
• end_price: The price after the leadin period of Bulk Coretime in the first sale.
• extra_cores: Number of extra cores that should be requested on top of the cores required for Reservations and Leases.

This will call Self::request_core_count internally to set the correct core count on the relay chain.

Fields

end_price: BalanceOf<T>

extra_cores: CoreIndex

purchase

Purchase Bulk Coretime in the ongoing Sale.

• origin: Must be a Signed origin with at least enough funds to pay the current price of Bulk Coretime.
• price_limit: An amount no more than which should be paid.

Fields

price_limit: BalanceOf<T>

renew

Renew Bulk Coretime in the ongoing Sale or its prior Interlude Period.

• origin: Must be a Signed origin with at least enough funds to pay the renewal price of the core.
• core: The core which should be renewed.

Fields

core: CoreIndex

transfer

Transfer a Bulk Coretime Region to a new owner.

• origin: Must be a Signed origin of the account which owns the Region region_id.
• region_id: The Region whose ownership should change.
• new_owner: The new owner for the Region.

Fields

region_id: RegionId

new_owner: T::AccountId

partition

Split a Bulk Coretime Region into two non-overlapping Regions at a particular time into the region.

• origin: Must be a Signed origin of the account which owns the Region region_id.
• region_id: The Region which should be partitioned into two non-overlapping Regions.
• pivot: The offset in time into the Region at which to make the split.

Fields

region_id: RegionId

pivot: Timeslice

interlace

Split a Bulk Coretime Region into two wholly-overlapping Regions with complementary interlace masks which together make up the original Region’s interlace mask.

• origin: Must be a Signed origin of the account which owns the Region region_id.
• region_id: The Region which should become two interlaced Regions of incomplete regularity.
• pivot: The interlace mask of one of the two new regions (the other is its partial complement).

Fields

region_id: RegionId

pivot: CoreMask

assign

Assign a Bulk Coretime Region to a task.

• origin: Must be a Signed origin of the account which owns the Region region_id.
• region_id: The Region which should be assigned to the task.
• task: The task to assign.
• finality: Indication of whether this assignment is final (in which case it may be eligible for renewal) or provisional (in which case it may be manipulated and/or reassigned at a later stage).

Fields

region_id: RegionId

task: TaskId

finality: Finality

pool

Place a Bulk Coretime Region into the Instantaneous Coretime Pool.

• origin: Must be a Signed origin of the account which owns the Region region_id.
• region_id: The Region which should be assigned to the Pool.
• payee: The account which is able to collect any revenue due for the usage of this Coretime.

Fields

region_id: RegionId

payee: T::AccountId

finality: Finality

claim_revenue

Claim the revenue owed from inclusion in the Instantaneous Coretime Pool.

• origin: Must be a Signed origin.
• region_id: The Region which was assigned to the Pool.
• max_timeslices: The maximum number of timeslices which should be processed. This must be greater than 0. This may affect the weight of the call but should be ideally made equivalent to the length of the Region region_id. If less, further dispatches will be required with the same region_id to claim revenue for the remainder.

Fields

region_id: RegionId

max_timeslices: Timeslice

purchase_credit

Purchase credit for use in the Instantaneous Coretime Pool.

• origin: Must be a Signed origin able to pay at least amount.
• amount: The amount of credit to purchase.
• beneficiary: The account on the Relay-chain which controls the credit (generally this will be the collator’s hot wallet).

Fields

amount: BalanceOf<T>

beneficiary: RelayAccountIdOf<T>

drop_region

Drop an expired Region from the chain.

• origin: Can be any kind of origin.
• region_id: The Region which has expired.

Fields

region_id: RegionId

drop_contribution

Drop an expired Instantaneous Pool Contribution record from the chain.

• origin: Can be any kind of origin.
• region_id: The Region identifying the Pool Contribution which has expired.

Fields

region_id: RegionId

drop_history

Drop an expired Instantaneous Pool History record from the chain.

• origin: Can be any kind of origin.
• region_id: The time of the Pool History record which has expired.

Fields

when: Timeslice

drop_renewal

Drop an expired Allowed Renewal record from the chain.

• origin: Can be any kind of origin.
• core: The core to which the expired renewal refers.
• when: The timeslice to which the expired renewal refers. This must have passed.

Fields

core: CoreIndex

when: Timeslice

request_core_count

Request a change to the number of cores available for scheduling work.

• origin: Must be Root or pass AdminOrigin.
• core_count: The desired number of cores to be made available.

Fields

core_count: CoreIndex

notify_core_count

Fields

core_count: CoreIndex

notify_revenue

Fields

revenue: OnDemandRevenueRecordOf<T>

enable_auto_renew

Extrinsic for enabling auto renewal.

Callable by the sovereign account of the task on the specified core. This account will be charged at the start of every bulk period for renewing core time.

• origin: Must be the sovereign account of the task
• core: The core to which the task to be renewed is currently assigned.
• task: The task for which we want to enable auto renewal.
• workload_end_hint: should be used when enabling auto-renewal for a core that is not expiring in the upcoming bulk period (e.g., due to holding a lease) since it would be inefficient to look up when the core expires to schedule the next renewal.

Fields

core: CoreIndex

task: TaskId

workload_end_hint: Option<Timeslice>

disable_auto_renew

Extrinsic for disabling auto renewal.

Callable by the sovereign account of the task on the specified core.

• origin: Must be the sovereign account of the task.
• core: The core for which we want to disable auto renewal.
• task: The task for which we want to disable auto renewal.

Fields

core: CoreIndex

task: TaskId

force_reserve

Reserve a core for a workload immediately.

• origin: Must be Root or pass AdminOrigin.
• workload: The workload which should be permanently placed on a core starting immediately.
• core: The core to which the assignment should be made until the reservation takes effect. It is left to the caller to either add this new core or reassign any other tasks to this existing core.

This reserves the workload and then injects the workload into the Workplan for the next two sale periods. This overwrites any existing assignments for this core at the start of the next sale period.

Fields

workload: Schedule

core: CoreIndex

remove_lease

Remove a lease.

• origin: Must be Root or pass AdminOrigin.
• task: The task id of the lease which should be removed.

Fields

task: TaskId

remove_assignment

Remove an assignment from the Workplan.

• origin: Must be Root or pass AdminOrigin.
• region_id: The Region to be removed from the workplan.

Fields

region_id: RegionId

swap_leases

Fields

id: TaskId

other: TaskId

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_configure(config: ConfigRecordOf<T>) -> Self

Create a call with the variant configure.

pub fn new_call_variant_reserve(workload: Schedule) -> Self

Create a call with the variant reserve.

pub fn new_call_variant_unreserve(item_index: u32) -> Self

Create a call with the variant unreserve.

pub fn new_call_variant_set_lease(task: TaskId, until: Timeslice) -> Self

Create a call with the variant set_lease.

pub fn new_call_variant_start_sales( end_price: BalanceOf<T>, extra_cores: CoreIndex, ) -> Self

Create a call with the variant start_sales.

pub fn new_call_variant_purchase(price_limit: BalanceOf<T>) -> Self

Create a call with the variant purchase.

pub fn new_call_variant_renew(core: CoreIndex) -> Self

Create a call with the variant renew.

pub fn new_call_variant_transfer( region_id: RegionId, new_owner: T::AccountId, ) -> Self

Create a call with the variant transfer.

pub fn new_call_variant_partition(region_id: RegionId, pivot: Timeslice) -> Self

Create a call with the variant partition.

pub fn new_call_variant_interlace(region_id: RegionId, pivot: CoreMask) -> Self

Create a call with the variant interlace.

pub fn new_call_variant_assign( region_id: RegionId, task: TaskId, finality: Finality, ) -> Self

Create a call with the variant assign.

pub fn new_call_variant_pool( region_id: RegionId, payee: T::AccountId, finality: Finality, ) -> Self

Create a call with the variant pool.

pub fn new_call_variant_claim_revenue( region_id: RegionId, max_timeslices: Timeslice, ) -> Self

Create a call with the variant claim_revenue.

pub fn new_call_variant_purchase_credit( amount: BalanceOf<T>, beneficiary: RelayAccountIdOf<T>, ) -> Self

Create a call with the variant purchase_credit.

pub fn new_call_variant_drop_region(region_id: RegionId) -> Self

Create a call with the variant drop_region.

pub fn new_call_variant_drop_contribution(region_id: RegionId) -> Self

Create a call with the variant drop_contribution.

pub fn new_call_variant_drop_history(when: Timeslice) -> Self

Create a call with the variant drop_history.

pub fn new_call_variant_drop_renewal(core: CoreIndex, when: Timeslice) -> Self

Create a call with the variant drop_renewal.

pub fn new_call_variant_request_core_count(core_count: CoreIndex) -> Self

Create a call with the variant request_core_count.

pub fn new_call_variant_notify_core_count(core_count: CoreIndex) -> Self

Create a call with the variant notify_core_count.

pub fn new_call_variant_notify_revenue( revenue: OnDemandRevenueRecordOf<T>, ) -> Self

Create a call with the variant notify_revenue.

pub fn new_call_variant_enable_auto_renew( core: CoreIndex, task: TaskId, workload_end_hint: Option<Timeslice>, ) -> Self

Create a call with the variant enable_auto_renew.

pub fn new_call_variant_disable_auto_renew( core: CoreIndex, task: TaskId, ) -> Self

Create a call with the variant disable_auto_renew.

pub fn new_call_variant_force_reserve( workload: Schedule, core: CoreIndex, ) -> Self

Create a call with the variant force_reserve.

pub fn new_call_variant_remove_lease(task: TaskId) -> Self

Create a call with the variant remove_lease.

pub fn new_call_variant_remove_assignment(region_id: RegionId) -> Self

Create a call with the variant remove_assignment.

pub fn new_call_variant_swap_leases(id: TaskId, other: TaskId) -> Self

Create a call with the variant swap_leases.

Trait Implementations

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

fn authorize( &self, source: TransactionSource, ) -> Option<Result<(ValidTransaction, Weight), TransactionValidityError>>

The authorize function.

fn weight_of_authorize(&self) -> Weight

The weight of the authorization function.

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 copy 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, ConfigRecordOf<T>: TypeInfo + 'static, BalanceOf<T>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, RelayAccountIdOf<T>: TypeInfo + 'static, OnDemandRevenueRecordOf<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 ConfigRecordOf<T>: DecodeWithMemTracking, BalanceOf<T>: DecodeWithMemTracking, T::AccountId: DecodeWithMemTracking, RelayAccountIdOf<T>: DecodeWithMemTracking, OnDemandRevenueRecordOf<T>: DecodeWithMemTracking,

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

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