Struct ChangeEpoch

pub struct ChangeEpoch {
    pub epoch: EpochId,
    pub protocol_version: ProtocolVersion,
    pub storage_charge: u64,
    pub computation_charge: u64,
    pub storage_rebate: u64,
    pub non_refundable_storage_fee: u64,
    pub epoch_start_timestamp_ms: u64,
    pub system_packages: Vec<SystemPackage>,
}

Fields

epoch: EpochId

The next (to become) epoch ID.

protocol_version: ProtocolVersion

The protocol version in effect in the new epoch.

storage_charge: u64

The total amount of gas charged for storage during the epoch.

computation_charge: u64

The total amount of gas charged for computation during the epoch.

storage_rebate: u64

The amount of storage rebate refunded to the txn senders.

non_refundable_storage_fee: u64

The non-refundable storage fee.

epoch_start_timestamp_ms: u64

Unix timestamp when epoch started

system_packages: Vec<SystemPackage>

System packages (specifically framework and move stdlib) that are written before the new epoch starts. This tracks framework upgrades on chain. When executing the ChangeEpoch txn, the validator must write out the modules below. Modules are provided with the version they will be upgraded to, their modules in serialized form (which include their package ID), and a list of their transitive dependencies.

Trait Implementations

impl Arbitrary for ChangeEpoch

type Parameters = ()

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

type Strategy = BoxedStrategy<ChangeEpoch>

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

fn arbitrary_with(args: <Self as Arbitrary>::Parameters) -> Self::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 ChangeEpoch

fn clone(&self) -> ChangeEpoch

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ChangeEpoch

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChangeEpoch

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ChangeEpoch

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ChangeEpoch

impl StructuralPartialEq for ChangeEpoch