Enum pallet_broker::pallet::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 {
        initial_price: BalanceOf<T>,
        core_count: 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,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

configure

Fields

config: ConfigRecordOf<T>

See Pallet::configure.

reserve

Fields

workload: Schedule

See Pallet::reserve.

unreserve

Fields

item_index: u32

See Pallet::unreserve.

set_lease

Fields

task: TaskId

until: Timeslice

See Pallet::set_lease.

start_sales

Fields

initial_price: BalanceOf<T>

core_count: CoreIndex

See Pallet::start_sales.

purchase

Fields

price_limit: BalanceOf<T>

See Pallet::purchase.

renew

Fields

core: CoreIndex

See Pallet::renew.

transfer

Fields

region_id: RegionId

new_owner: T::AccountId

See Pallet::transfer.

partition

Fields

region_id: RegionId

pivot: Timeslice

See Pallet::partition.

interlace

Fields

region_id: RegionId

pivot: CoreMask

See Pallet::interlace.

assign

Fields

region_id: RegionId

task: TaskId

finality: Finality

See Pallet::assign.

pool

Fields

region_id: RegionId

payee: T::AccountId

finality: Finality

See Pallet::pool.

claim_revenue

Fields

region_id: RegionId

max_timeslices: Timeslice

See Pallet::claim_revenue.

purchase_credit

Fields

amount: BalanceOf<T>

beneficiary: RelayAccountIdOf<T>

See Pallet::purchase_credit.

drop_region

Fields

region_id: RegionId

See Pallet::drop_region.

drop_contribution

Fields

region_id: RegionId

See Pallet::drop_contribution.

drop_history

Fields

when: Timeslice

See Pallet::drop_history.

drop_renewal

Fields

core: CoreIndex

when: Timeslice

See Pallet::drop_renewal.

request_core_count

Fields

core_count: CoreIndex

See Pallet::request_core_count.

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( initial_price: BalanceOf<T>, core_count: 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.

Trait Implementations

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 encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere 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<Call<T>> for Call<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method 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, 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> EncodeLike<Call<T>> for Call<T>

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