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: RelayBlockNumberOf<T>,
        leadin_length: RelayBlockNumberOf<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

A Region of Bulk Coretime has been 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.

Renewable

The workload of a core has become 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.

Renewed

A workload has been 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.

Transferred

Ownership of a Region has been 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.

Partitioned

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

Fields

old_region_id: RegionId

The Region which was split.

new_region_ids: (RegionId, RegionId)

The new Regions into which it became.

Interlaced

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

Fields

old_region_id: RegionId

The Region which was interlaced.

new_region_ids: (RegionId, RegionId)

The new Regions into which it became.

Assigned

A Region has been assigned to a particular task.

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.

Pooled

A Region has been added to the Instantaneous Coretime Pool.

Fields

region_id: RegionId

The Region which was added to the Instantaneous Coretime Pool.

duration: Timeslice

The duration of the Region.

CoreCountRequested

A new number of cores has been requested.

Fields

core_count: CoreIndex

The number of cores requested.

CoreCountChanged

The number of cores available for scheduling has changed.

Fields

core_count: CoreIndex

The new number of cores available for scheduling.

ReservationMade

There is a new reservation for a workload.

Fields

index: u32

The index of the reservation.

workload: Schedule

The workload of the reservation.

ReservationCancelled

A reservation for a workload has been cancelled.

Fields

index: u32

The index of the reservation which was cancelled.

workload: Schedule

The workload of the now cancelled reservation.

SaleInitialized

A new sale has been initialized.

Fields

sale_start: RelayBlockNumberOf<T>

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

leadin_length: RelayBlockNumberOf<T>

The length in relay chain 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.

Leased

A new lease has been created.

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).

LeaseEnding

A lease is about to end.

Fields

task: TaskId

The task to which a core was assigned.

when: Timeslice

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

SalesStarted

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

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.

RevenueClaimBegun

The act of claiming revenue has begun.

Fields

region: RegionId

The region to be claimed for.

max_timeslices: Timeslice

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

RevenueClaimItem

A particular timeslice has a non-zero claim.

Fields

when: Timeslice

The timeslice whose claim is being processed.

amount: BalanceOf<T>

The amount which was claimed at this timeslice.

RevenueClaimPaid

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

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.

CreditPurchased

Some Instantaneous Coretime Pool credit has been purchased.

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.

RegionDropped

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

Fields

region_id: RegionId

The Region which no longer exists.

duration: Timeslice

The duration of the Region.

ContributionDropped

Some historical Instantaneous Core Pool contribution record has been dropped.

Fields

region_id: RegionId

The Region whose contribution is no longer exists.

HistoryInitialized

Some historical Instantaneous Core Pool payment record has been initialized.

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.

HistoryDropped

Some historical Instantaneous Core Pool payment record has been dropped.

Fields

when: Timeslice

The timeslice whose history is no longer available.

revenue: BalanceOf<T>

The amount of revenue the system has taken.

HistoryIgnored

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

Fields

when: Timeslice

The timeslice whose history is was ignored.

revenue: BalanceOf<T>

The amount of revenue which was ignored.

ClaimsReady

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

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.

CoreAssigned

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

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.

PotentialRenewalDropped

Some historical Instantaneous Core Pool payment record has been dropped.

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.

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

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

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.

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, RelayBlockNumberOf<T>: Decode, RelayAccountIdOf<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, RelayBlockNumberOf<T>: Encode, RelayAccountIdOf<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, RelayBlockNumberOf<T>: TypeInfo + 'static, RelayAccountIdOf<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, RelayBlockNumberOf<T>: Encode, RelayAccountIdOf<T>: Encode,

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