Enum EndOfEpochTransactionKind 

#[non_exhaustive]
pub enum EndOfEpochTransactionKind {
    ChangeEpoch(ChangeEpoch),
    ChangeEpochV2(ChangeEpochV2),
    ChangeEpochV3(ChangeEpochV3),
    ChangeEpochV4(ChangeEpochV4),
}

Operation run at the end of an epoch

BCS

The BCS serialized form for this type is defined by the following ABNF:

end-of-epoch-transaction-kind =  %d00 change-epoch     ; ChangeEpoch
                              =/ %d01 change-epoch-v2  ; ChangeEpochV2
                              =/ %d02 change-epoch-v3  ; ChangeEpochV3
                              =/ %d03 change-epoch-v4  ; ChangeEpochV4

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ChangeEpoch(ChangeEpoch)

End the epoch and start the next one

ChangeEpochV2(ChangeEpochV2)

End the epoch and start the next one

ChangeEpochV3(ChangeEpochV3)

End the epoch and start the next one

ChangeEpochV4(ChangeEpochV4)

End the epoch and start the next one

Implementations

impl EndOfEpochTransactionKind

pub fn is_change_epoch(&self) -> bool

Checks if this is a change_epoch variant.

pub fn as_change_epoch(&self) -> &ChangeEpoch

Converts this into a change_epoch if it is a change_epoch variant, or panics otherwise.

pub fn as_change_epoch_mut(&mut self) -> &mut ChangeEpoch

Converts this into a mut change_epoch if it is a change_epoch variant, or panics otherwise.

pub fn as_change_epoch_opt(&self) -> Option<&ChangeEpoch>

Converts this into a change_epoch if it is a change_epoch variant, or returns None otherwise.

pub fn as_change_epoch_mut_opt(&mut self) -> Option<&mut ChangeEpoch>

Converts this into a mut change_epoch if it is a change_epoch variant, or returns None otherwise.

pub fn into_change_epoch_opt(self) -> Option<ChangeEpoch>

Converts this into a change_epoch if it is a change_epoch variant, or returns None otherwise.

pub fn into_change_epoch(self) -> ChangeEpoch

Converts this into a change_epoch if it is a change_epoch variant, or panics otherwise.

pub fn is_change_epoch_v2(&self) -> bool

Checks if this is a change_epoch_v2 variant.

pub fn as_change_epoch_v2(&self) -> &ChangeEpochV2

Converts this into a change_epoch_v2 if it is a change_epoch_v2 variant, or panics otherwise.

pub fn as_change_epoch_v2_mut(&mut self) -> &mut ChangeEpochV2

Converts this into a mut change_epoch_v2 if it is a change_epoch_v2 variant, or panics otherwise.

pub fn as_change_epoch_v2_opt(&self) -> Option<&ChangeEpochV2>

Converts this into a change_epoch_v2 if it is a change_epoch_v2 variant, or returns None otherwise.

pub fn as_change_epoch_v2_mut_opt(&mut self) -> Option<&mut ChangeEpochV2>

Converts this into a mut change_epoch_v2 if it is a change_epoch_v2 variant, or returns None otherwise.

pub fn into_change_epoch_v2_opt(self) -> Option<ChangeEpochV2>

Converts this into a change_epoch_v2 if it is a change_epoch_v2 variant, or returns None otherwise.

pub fn into_change_epoch_v2(self) -> ChangeEpochV2

Converts this into a change_epoch_v2 if it is a change_epoch_v2 variant, or panics otherwise.

pub fn is_change_epoch_v3(&self) -> bool

Checks if this is a change_epoch_v3 variant.

pub fn as_change_epoch_v3(&self) -> &ChangeEpochV3

Converts this into a change_epoch_v3 if it is a change_epoch_v3 variant, or panics otherwise.

pub fn as_change_epoch_v3_mut(&mut self) -> &mut ChangeEpochV3

Converts this into a mut change_epoch_v3 if it is a change_epoch_v3 variant, or panics otherwise.

pub fn as_change_epoch_v3_opt(&self) -> Option<&ChangeEpochV3>

Converts this into a change_epoch_v3 if it is a change_epoch_v3 variant, or returns None otherwise.

pub fn as_change_epoch_v3_mut_opt(&mut self) -> Option<&mut ChangeEpochV3>

Converts this into a mut change_epoch_v3 if it is a change_epoch_v3 variant, or returns None otherwise.

pub fn into_change_epoch_v3_opt(self) -> Option<ChangeEpochV3>

Converts this into a change_epoch_v3 if it is a change_epoch_v3 variant, or returns None otherwise.

pub fn into_change_epoch_v3(self) -> ChangeEpochV3

Converts this into a change_epoch_v3 if it is a change_epoch_v3 variant, or panics otherwise.

pub fn is_change_epoch_v4(&self) -> bool

Checks if this is a change_epoch_v4 variant.

pub fn as_change_epoch_v4(&self) -> &ChangeEpochV4

Converts this into a change_epoch_v4 if it is a change_epoch_v4 variant, or panics otherwise.

pub fn as_change_epoch_v4_mut(&mut self) -> &mut ChangeEpochV4

Converts this into a mut change_epoch_v4 if it is a change_epoch_v4 variant, or panics otherwise.

pub fn as_change_epoch_v4_opt(&self) -> Option<&ChangeEpochV4>

Converts this into a change_epoch_v4 if it is a change_epoch_v4 variant, or returns None otherwise.

pub fn as_change_epoch_v4_mut_opt(&mut self) -> Option<&mut ChangeEpochV4>

Converts this into a mut change_epoch_v4 if it is a change_epoch_v4 variant, or returns None otherwise.

pub fn into_change_epoch_v4_opt(self) -> Option<ChangeEpochV4>

Converts this into a change_epoch_v4 if it is a change_epoch_v4 variant, or returns None otherwise.

pub fn into_change_epoch_v4(self) -> ChangeEpochV4

Converts this into a change_epoch_v4 if it is a change_epoch_v4 variant, or panics otherwise.

pub fn new_change_epoch( next_epoch: u64, protocol_version: u64, storage_charge: u64, computation_charge: u64, storage_rebate: u64, non_refundable_storage_fee: u64, epoch_start_timestamp_ms: u64, system_packages: Vec<SystemPackage>, ) -> EndOfEpochTransactionKind

Creates a ChangeEpoch end-of-epoch transaction kind.

pub fn new_change_epoch_v2( next_epoch: u64, protocol_version: u64, storage_charge: u64, computation_charge: u64, computation_charge_burned: u64, storage_rebate: u64, non_refundable_storage_fee: u64, epoch_start_timestamp_ms: u64, system_packages: Vec<SystemPackage>, ) -> EndOfEpochTransactionKind

Creates a ChangeEpochV2 end-of-epoch transaction kind.

pub fn new_change_epoch_v3( next_epoch: u64, protocol_version: u64, storage_charge: u64, computation_charge: u64, computation_charge_burned: u64, storage_rebate: u64, non_refundable_storage_fee: u64, epoch_start_timestamp_ms: u64, system_packages: Vec<SystemPackage>, eligible_active_validators: Vec<u64>, ) -> EndOfEpochTransactionKind

Creates a ChangeEpochV3 end-of-epoch transaction kind.

pub fn new_change_epoch_v4( next_epoch: u64, protocol_version: u64, storage_charge: u64, computation_charge: u64, computation_charge_burned: u64, storage_rebate: u64, non_refundable_storage_fee: u64, epoch_start_timestamp_ms: u64, system_packages: Vec<SystemPackage>, eligible_active_validators: Vec<u64>, scores: Vec<u64>, adjust_rewards_by_score: bool, ) -> EndOfEpochTransactionKind

Creates a ChangeEpochV4 end-of-epoch transaction kind.

pub fn shared_input_objects( &self, ) -> impl Iterator<Item = SharedObjectReference>

Returns an iterator over the shared input objects required by this transaction kind.

Trait Implementations

impl Arbitrary for EndOfEpochTransactionKind

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<EndOfEpochTransactionKind>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( args_shared: <EndOfEpochTransactionKind as Arbitrary>::Parameters, ) -> <EndOfEpochTransactionKind as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for EndOfEpochTransactionKind

fn clone(&self) -> EndOfEpochTransactionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EndOfEpochTransactionKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EndOfEpochTransactionKind

fn deserialize<D>( deserializer: D, ) -> Result<EndOfEpochTransactionKind, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for EndOfEpochTransactionKind

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EndOfEpochTransactionKind

fn eq(&self, other: &EndOfEpochTransactionKind) -> 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 Serialize for EndOfEpochTransactionKind

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for EndOfEpochTransactionKind

impl StructuralPartialEq for EndOfEpochTransactionKind