Struct ExtraFieldsToSerialize 

pub struct ExtraFieldsToSerialize {
    pub lamports_per_signature: u64,
    pub unused_incremental_snapshot_persistence: Option<UnusedIncrementalSnapshotPersistence>,
    pub unused_epoch_accounts_hash: Option<Hash>,
    pub versioned_epoch_stakes: HashMap<u64, VersionedEpochStakes>,
    pub accounts_lt_hash: Option<SerdeAccountsLtHash>,
    pub block_id: Option<Hash>,
}

Extra fields that are serialized at the end of snapshots.

Note that this struct’s fields should stay synced with the fields in ExtraFieldsToDeserialize with the exception that new “extra fields” should be added to the deserialize struct a minor release before they are added to this one.

Fields

lamports_per_signature: u64

unused_incremental_snapshot_persistence: Option<UnusedIncrementalSnapshotPersistence>

unused_epoch_accounts_hash: Option<Hash>

versioned_epoch_stakes: HashMap<u64, VersionedEpochStakes>

accounts_lt_hash: Option<SerdeAccountsLtHash>

block_id: Option<Hash>

Trait Implementations

impl AbiExample for ExtraFieldsToSerialize

fn example() -> Self

impl Debug for ExtraFieldsToSerialize

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

Formats the value using the given formatter.

impl Default for ExtraFieldsToSerialize

fn default() -> ExtraFieldsToSerialize

Returns the “default value” for a type.

impl Distribution<ExtraFieldsToSerialize> for StandardUniform

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> ExtraFieldsToSerialize

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl PartialEq for ExtraFieldsToSerialize

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StableAbi for ExtraFieldsToSerialize

fn random_with_context(rng: &mut (impl RngCore + ?Sized), _ctx: ()) -> Self

fn random(rng: &mut (impl RngCore + ?Sized)) -> Self

where Ctx: Default,

impl StructuralPartialEq for ExtraFieldsToSerialize