Struct Xp

pub struct Xp<T: Config<I>, I: 'static> {
    pub free: T::Xp,
    pub reserve: T::Xp,
    pub lock: T::Xp,
    pub pulse: Accumulator<T, I>,
    pub timestamp: BlockNumberFor<T>,
}

The main XP data structure that is utilized on implementation of XpSystem::Xp.

It provides a high-level detail for managing liquid points, reserved points, locked points, and reputation-based pulse tracking with timestamp information.

Point Categories

• Free Points: Liquid XP that the owner can freely access and use.
• Reserved Points: XP temporarily set aside for Runtime specific purposes.
• Locked Points: XP that is restricted by the Runtime provider (other pallets) or implementor.

Reputation System

• Pulse: A discrete accumulator that tracks XP mutation frequency for reputation.
• Timestamp: Block number of the last XP increment for heartbeat tracking.

Fields

free: T::Xp

Liquid XP points that the owner can freely access.

reserve: T::Xp

Reserved XP points that are temporarily set aside for specific purposes.

This field aggregates all reserved XP across different RuntimeReasons, enabling efficient access to the total reserved balance without needing to iterate through individual reservation records.

lock: T::Xp

Locked XP points that are restricted by the Runtime provider or implementor.

This field aggregates all locked XP across different RuntimeReasons, enabling efficient access to the total locked balance without needing to iterate through individual lock records.

pulse: Accumulator<T, I>

Reputation-based pulse accumulator that tracks XP mutation frequency.

The provider represents the runtime intent, awarding XP based on completed work.

The pulse acts as a “heartbeat” of XP activity, serving as a reputational metric for each XP account. It is proportional to the frequency and amount of XP increments, and may influence the raw XP awarded for future actions.

In an untrusted environment, pulse is used as a reputational resource, allowing the system to adjust raw XP based on the quality and consistency of the account’s activity as reflected by its pulse.

timestamp: BlockNumberFor<T>

The block number at which XP was last incremented.

This timestamp is used to identify inactive (“dead”) XP accounts and can be leveraged to conditionally determine whether to increase reputation (i.e., pulse) based on recent activity, or if the XP is subjected to reaping procedures.

Trait Implementations

impl<T: Config<I>, I: 'static> Clone for Xp<T, I>

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<I>, I: 'static> Debug for Xp<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for Xp<T, I>

where T::Xp: Decode, Accumulator<T, I>: Decode, BlockNumberFor<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<I>, I: 'static> Default for Xp<T, I>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Config<I>, I: 'static> Encode for Xp<T, I>

where T::Xp: Encode, Accumulator<T, I>: Encode, BlockNumberFor<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<I>, I: 'static> MaxEncodedLen for Xp<T, I>

where T::Xp: MaxEncodedLen, Accumulator<T, I>: MaxEncodedLen, BlockNumberFor<T>: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: Config<I>, I: 'static> PartialEq for Xp<T, I>

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, I> TypeInfo for Xp<T, I>

where T::Xp: TypeInfo + 'static, Accumulator<T, I>: TypeInfo + 'static, BlockNumberFor<T>: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

type Identity = Xp<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Copy + Config<I>, I: Copy + 'static> Copy for Xp<T, I>

where T::Xp: Copy,

impl<T: Config<I>, I: 'static> DecodeWithMemTracking for Xp<T, I>

where T::Xp: DecodeWithMemTracking, Accumulator<T, I>: DecodeWithMemTracking, BlockNumberFor<T>: DecodeWithMemTracking,

impl<T: Config<I>, I: 'static> EncodeLike for Xp<T, I>

where T::Xp: Encode, Accumulator<T, I>: Encode, BlockNumberFor<T>: Encode,

impl<T: Config<I>, I: 'static> Eq for Xp<T, I>