Struct OffenceRecord 

pub struct OffenceRecord<AccountId> {
    pub reporter: Option<AccountId>,
    pub reported_era: EraIndex,
    pub exposure_page: u32,
    pub slash_fraction: Perbill,
    pub prior_slash_fraction: Perbill,
}

Represents an offence record within the staking system, capturing details about a slashing event.

Fields

reporter: Option<AccountId>

The account ID of the entity that reported the offence.

reported_era: EraIndex

Era at which the offence was reported.

exposure_page: u32

The specific page of the validator’s exposure currently being processed.

Since a validator’s total exposure can span multiple pages, this field serves as a pointer to the current page being evaluated. The processing order starts from the last page and moves backward, decrementing this value with each processed page.

This ensures that all pages are systematically handled, and it helps track when the entire exposure has been processed.

slash_fraction: Perbill

The fraction of the validator’s stake to be slashed for this offence.

prior_slash_fraction: Perbill

The previous slash fraction of the validator’s stake before being updated. If a new, higher slash fraction is reported, this field stores the prior fraction that was overwritten. This helps in tracking changes in slashes across multiple reports for the same era.

Trait Implementations

impl<AccountId: Clone> Clone for OffenceRecord<AccountId>

fn clone(&self) -> OffenceRecord<AccountId>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<AccountId> Debug for OffenceRecord<AccountId>

where AccountId: Debug,

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

Formats the value using the given formatter.

impl<AccountId> Decode for OffenceRecord<AccountId>

where Option<AccountId>: 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<AccountId> Encode for OffenceRecord<AccountId>

where Option<AccountId>: 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<AccountId> MaxEncodedLen for OffenceRecord<AccountId>

where Option<AccountId>: MaxEncodedLen,

fn max_encoded_len() -> usize

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

impl<AccountId: PartialEq> PartialEq for OffenceRecord<AccountId>

fn eq(&self, other: &OffenceRecord<AccountId>) -> 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<AccountId> TypeInfo for OffenceRecord<AccountId>

where Option<AccountId>: TypeInfo + 'static, AccountId: TypeInfo + 'static,

type Identity = OffenceRecord<AccountId>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AccountId> EncodeLike for OffenceRecord<AccountId>

where Option<AccountId>: Encode,

impl<AccountId> StructuralPartialEq for OffenceRecord<AccountId>