Enum pallet_broker::pallet::Event

pub enum Event<T: Config> {
    Purchased {
        who: T::AccountId,
        region_id: RegionId,
        price: BalanceOf<T>,
        duration: Timeslice,
    },
    Renewable {
        core: CoreIndex,
        price: BalanceOf<T>,
        begin: Timeslice,
        workload: Schedule,
    },
    Renewed {
        who: T::AccountId,
        price: BalanceOf<T>,
        old_core: CoreIndex,
        core: CoreIndex,
        begin: Timeslice,
        duration: Timeslice,
        workload: Schedule,
    },
    Transferred {
        region_id: RegionId,
        duration: Timeslice,
        old_owner: Option<T::AccountId>,
        owner: Option<T::AccountId>,
    },
    Partitioned {
        old_region_id: RegionId,
        new_region_ids: (RegionId, RegionId),
    },
    Interlaced {
        old_region_id: RegionId,
        new_region_ids: (RegionId, RegionId),
    },
    Assigned {
        region_id: RegionId,
        duration: Timeslice,
        task: TaskId,
    },
    Pooled {
        region_id: RegionId,
        duration: Timeslice,
    },
    CoreCountRequested {
        core_count: CoreIndex,
    },
    CoreCountChanged {
        core_count: CoreIndex,
    },
    ReservationMade {
        index: u32,
        workload: Schedule,
    },
    ReservationCancelled {
        index: u32,
        workload: Schedule,
    },
    SaleInitialized {
        sale_start: BlockNumberFor<T>,
        leadin_length: BlockNumberFor<T>,
        start_price: BalanceOf<T>,
        end_price: BalanceOf<T>,
        region_begin: Timeslice,
        region_end: Timeslice,
        ideal_cores_sold: CoreIndex,
        cores_offered: CoreIndex,
    },
    Leased {
        task: TaskId,
        until: Timeslice,
    },
    LeaseEnding {
        task: TaskId,
        when: Timeslice,
    },
    SalesStarted {
        price: BalanceOf<T>,
        core_count: CoreIndex,
    },
    RevenueClaimBegun {
        region: RegionId,
        max_timeslices: Timeslice,
    },
    RevenueClaimItem {
        when: Timeslice,
        amount: BalanceOf<T>,
    },
    RevenueClaimPaid {
        who: T::AccountId,
        amount: BalanceOf<T>,
        next: Option<RegionId>,
    },
    CreditPurchased {
        who: T::AccountId,
        beneficiary: RelayAccountIdOf<T>,
        amount: BalanceOf<T>,
    },
    RegionDropped {
        region_id: RegionId,
        duration: Timeslice,
    },
    ContributionDropped {
        region_id: RegionId,
    },
    HistoryInitialized {
        when: Timeslice,
        private_pool_size: CoreMaskBitCount,
        system_pool_size: CoreMaskBitCount,
    },
    HistoryDropped {
        when: Timeslice,
        revenue: BalanceOf<T>,
    },
    HistoryIgnored {
        when: Timeslice,
        revenue: BalanceOf<T>,
    },
    ClaimsReady {
        when: Timeslice,
        system_payout: BalanceOf<T>,
        private_payout: BalanceOf<T>,
    },
    CoreAssigned {
        core: CoreIndex,
        when: RelayBlockNumberOf<T>,
        assignment: Vec<(CoreAssignment, PartsOf57600)>,
    },
    PotentialRenewalDropped {
        when: Timeslice,
        core: CoreIndex,
    },
    AutoRenewalEnabled {
        core: CoreIndex,
        task: TaskId,
    },
    AutoRenewalDisabled {
        core: CoreIndex,
        task: TaskId,
    },
    AutoRenewalFailed {
        core: CoreIndex,
        payer: Option<T::AccountId>,
    },
    AutoRenewalLimitReached,
    // some variants omitted
}

The Event enum of this pallet

Variants

Purchased

Fields

who: T::AccountId

The identity of the purchaser.

region_id: RegionId

The identity of the Region.

price: BalanceOf<T>

The price paid for this Region.

duration: Timeslice

The duration of the Region.

A Region of Bulk Coretime has been purchased.

Renewable

Fields

core: CoreIndex

The core whose workload can be renewed.

price: BalanceOf<T>

The price at which the workload can be renewed.

begin: Timeslice

The time at which the workload would recommence of this renewal. The call to renew cannot happen before the beginning of the interlude prior to the sale for regions which begin at this time.

workload: Schedule

The actual workload which can be renewed.

The workload of a core has become renewable.

Renewed

Fields

who: T::AccountId

The identity of the renewer.

price: BalanceOf<T>

The price paid for this renewal.

old_core: CoreIndex

The index of the core on which the workload was previously scheduled.

core: CoreIndex

The index of the core on which the renewed workload has been scheduled.

begin: Timeslice

The time at which the workload will begin on the core.

duration: Timeslice

The number of timeslices for which this workload is newly scheduled.

workload: Schedule

The workload which was renewed.

A workload has been renewed.

Transferred

Fields

region_id: RegionId

The Region which has been transferred.

duration: Timeslice

The duration of the Region.

old_owner: Option<T::AccountId>

The old owner of the Region.

owner: Option<T::AccountId>

The new owner of the Region.

Ownership of a Region has been transferred.

Partitioned

Fields

old_region_id: RegionId

The Region which was split.

new_region_ids: (RegionId, RegionId)

The new Regions into which it became.

A Region has been split into two non-overlapping Regions.

Interlaced

Fields

old_region_id: RegionId

The Region which was interlaced.

new_region_ids: (RegionId, RegionId)

The new Regions into which it became.

A Region has been converted into two overlapping Regions each of lesser regularity.

Assigned

Fields

region_id: RegionId

The Region which was assigned.

duration: Timeslice

The duration of the assignment.

task: TaskId

The task to which the Region was assigned.

A Region has been assigned to a particular task.

Pooled

Fields

region_id: RegionId

The Region which was added to the Instantaneous Coretime Pool.

duration: Timeslice

The duration of the Region.

A Region has been added to the Instantaneous Coretime Pool.

CoreCountRequested

Fields

core_count: CoreIndex

The number of cores requested.

A new number of cores has been requested.

CoreCountChanged

Fields

core_count: CoreIndex

The new number of cores available for scheduling.

The number of cores available for scheduling has changed.

ReservationMade

Fields

index: u32

The index of the reservation.

workload: Schedule

The workload of the reservation.

There is a new reservation for a workload.

ReservationCancelled

Fields

index: u32

The index of the reservation which was cancelled.

workload: Schedule

The workload of the now cancelled reservation.

A reservation for a workload has been cancelled.

SaleInitialized

Fields

sale_start: BlockNumberFor<T>

The local block number at which the sale will/did start.

leadin_length: BlockNumberFor<T>

The length in blocks of the Leadin Period (where the price is decreasing).

start_price: BalanceOf<T>

The price of Bulk Coretime at the beginning of the Leadin Period.

end_price: BalanceOf<T>

The price of Bulk Coretime after the Leadin Period.

region_begin: Timeslice

The first timeslice of the Regions which are being sold in this sale.

region_end: Timeslice

The timeslice on which the Regions which are being sold in the sale terminate. (i.e. One after the last timeslice which the Regions control.)

ideal_cores_sold: CoreIndex

The number of cores we want to sell, ideally.

cores_offered: CoreIndex

Number of cores which are/have been offered for sale.

A new sale has been initialized.

Leased

Fields

task: TaskId

The task to which a core will be assigned.

until: Timeslice

The timeslice contained in the sale period after which this lease will self-terminate (and therefore the earliest timeslice at which the lease may no longer apply).

A new lease has been created.

LeaseEnding

Fields

task: TaskId

The task to which a core was assigned.

when: Timeslice

The timeslice at which the task will no longer be scheduled.

A lease is about to end.

SalesStarted

Fields

price: BalanceOf<T>

The nominal price of an Region of Bulk Coretime.

core_count: CoreIndex

The maximum number of cores which this pallet will attempt to assign.

The sale rotation has been started and a new sale is imminent.

RevenueClaimBegun

Fields

region: RegionId

The region to be claimed for.

max_timeslices: Timeslice

The maximum number of timeslices which should be searched for claimed.

The act of claiming revenue has begun.

RevenueClaimItem

Fields

when: Timeslice

The timeslice whose claim is being processed.

amount: BalanceOf<T>

The amount which was claimed at this timeslice.

A particular timeslice has a non-zero claim.

RevenueClaimPaid

Fields

who: T::AccountId

The account to whom revenue has been paid.

amount: BalanceOf<T>

The total amount of revenue claimed and paid.

next: Option<RegionId>

The next region which should be claimed for the continuation of this contribution.

A revenue claim has (possibly only in part) been paid.

CreditPurchased

Fields

who: T::AccountId

The account which purchased the credit.

beneficiary: RelayAccountIdOf<T>

The Relay-chain account to which the credit will be made.

amount: BalanceOf<T>

The amount of credit purchased.

Some Instantaneous Coretime Pool credit has been purchased.

RegionDropped

Fields

region_id: RegionId

The Region which no longer exists.

duration: Timeslice

The duration of the Region.

A Region has been dropped due to being out of date.

ContributionDropped

Fields

region_id: RegionId

The Region whose contribution is no longer exists.

Some historical Instantaneous Core Pool contribution record has been dropped.

HistoryInitialized

Fields

when: Timeslice

The timeslice whose history has been initialized.

private_pool_size: CoreMaskBitCount

The amount of privately contributed Coretime to the Instantaneous Coretime Pool.

system_pool_size: CoreMaskBitCount

The amount of Coretime contributed to the Instantaneous Coretime Pool by the Polkadot System.

Some historical Instantaneous Core Pool payment record has been initialized.

HistoryDropped

Fields

when: Timeslice

The timeslice whose history is no longer available.

revenue: BalanceOf<T>

The amount of revenue the system has taken.

Some historical Instantaneous Core Pool payment record has been dropped.

HistoryIgnored

Fields

when: Timeslice

The timeslice whose history is was ignored.

revenue: BalanceOf<T>

The amount of revenue which was ignored.

Some historical Instantaneous Core Pool payment record has been ignored because the timeslice was already known. Governance may need to intervene.

ClaimsReady

Fields

when: Timeslice

The timeslice whose history is available.

system_payout: BalanceOf<T>

The amount of revenue the Polkadot System has already taken.

private_payout: BalanceOf<T>

The total amount of revenue remaining to be claimed.

Some historical Instantaneous Core Pool Revenue is ready for payout claims.

CoreAssigned

Fields

core: CoreIndex

The index of the Core which has been assigned.

when: RelayBlockNumberOf<T>

The Relay-chain block at which this assignment should take effect.

assignment: Vec<(CoreAssignment, PartsOf57600)>

The workload to be done on the Core.

A Core has been assigned to one or more tasks and/or the Pool on the Relay-chain.

PotentialRenewalDropped

Fields

when: Timeslice

The timeslice whose renewal is no longer available.

core: CoreIndex

The core whose workload is no longer available to be renewed for when.

Some historical Instantaneous Core Pool payment record has been dropped.

AutoRenewalEnabled

Fields

core: CoreIndex

The core for which the renewal was enabled.

task: TaskId

The task for which the renewal was enabled.

AutoRenewalDisabled

Fields

core: CoreIndex

The core for which the renewal was disabled.

task: TaskId

The task for which the renewal was disabled.

AutoRenewalFailed

Fields

core: CoreIndex

The core for which the renewal failed.

payer: Option<T::AccountId>

The account which was supposed to pay for renewal.

If None it indicates that we failed to get the sovereign account of a task.

Failed to auto-renew a core, likely due to the payer account not being sufficiently funded.

AutoRenewalLimitReached

The auto-renewal limit has been reached upon renewing cores.

This should never happen, given that enable_auto_renew checks for this before enabling auto-renewal.

Trait Implementations

impl<T: Config> Clone for Event<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 Event<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for Event<T>

where T::AccountId: Decode, BalanceOf<T>: Decode, Option<T::AccountId>: Decode, BlockNumberFor<T>: Decode, RelayAccountIdOf<T>: Decode, RelayBlockNumberOf<T>: Decode,

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 Event<T>

where T::AccountId: Encode, BalanceOf<T>: Encode, Option<T::AccountId>: Encode, BlockNumberFor<T>: Encode, RelayAccountIdOf<T>: Encode, RelayBlockNumberOf<T>: Encode,

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<Event<T>> for ()

fn from(_: Event<T>)

Converts to this type from the input type.

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

where T::AccountId: TypeInfo + 'static, BalanceOf<T>: TypeInfo + 'static, Option<T::AccountId>: TypeInfo + 'static, BlockNumberFor<T>: TypeInfo + 'static, RelayAccountIdOf<T>: TypeInfo + 'static, RelayBlockNumberOf<T>: TypeInfo + 'static, PhantomData<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = Event<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

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

where T::AccountId: Encode, BalanceOf<T>: Encode, Option<T::AccountId>: Encode, BlockNumberFor<T>: Encode, RelayAccountIdOf<T>: Encode, RelayBlockNumberOf<T>: Encode,

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