Struct radix_engine::blueprints::consensus_manager::ValidatorSubstate

pub struct ValidatorSubstate {

    pub sorted_key: Option<SortedKey>,
    pub key: Secp256k1PublicKey,
    pub is_registered: bool,
    pub accepts_delegated_stake: bool,
    pub validator_fee_factor: Decimal,
    pub validator_fee_change_request: Option<ValidatorFeeChangeRequest>,
    pub stake_unit_resource: ResourceAddress,
    pub stake_xrd_vault_id: Own,
    pub claim_nft: ResourceAddress,
    pub pending_xrd_withdraw_vault_id: Own,
    pub locked_owner_stake_unit_vault_id: Own,
    pub pending_owner_stake_unit_unlock_vault_id: Own,
    pub pending_owner_stake_unit_withdrawals: BTreeMap<Epoch, Decimal>,
    pub already_unlocked_owner_stake_unit_amount: Decimal,
}

Fields

sorted_key: Option<SortedKey>

A key used internally for storage of registered validators sorted by their stake descending. It is only useful when the validator is registered and has non-zero stake - hence, the field is None otherwise. Note: in theory, this value could be always computed from the [is_registered] status and the amount stored in [stake_xrd_vault_id]; we simply keep it cached to simplify certain updates.

key: Secp256k1PublicKey

This validator’s public key.

is_registered: bool

Whether this validator is currently interested in participating in the consensus.

accepts_delegated_stake: bool

Whether this validator is currently accepting delegated stake or not

validator_fee_factor: Decimal

A fraction of the effective emission amount which gets transferred to the validator’s owner (by staking it and depositing the stake units to the [locked_owner_stake_unit_vault_id]). Note: it is a decimal factor, not a percentage (i.e. 0.015 means “1.5%” here). Note: it may be overridden by [validator_fee_change_request], if it contains a change which already became effective.

validator_fee_change_request: Option<ValidatorFeeChangeRequest>

The most recent request to change the [validator_fee_factor] (which requires a delay). Note: the value from this request will be used instead of [validator_fee_factor] if the request has already reached its effective epoch. Note: when another change is requested, the value from this (previous) one is moved to the [validator_fee_factor] - provided that it became already effective. Otherwise, this request is overwritten by the new one.

stake_unit_resource: ResourceAddress

A type of fungible resource representing stake units specific to this validator. Conceptually, “staking to validator A” means “contributing to the validator’s staking pool, and receiving the validator’s stake units which act as the pool units for the staking pool”.

stake_xrd_vault_id: Own

A vault holding the XRDs currently staked to this validator.

claim_nft: ResourceAddress

A type of non-fungible token used as a receipt for unstaked stake units. Unstaking burns the SUs and inactivates the staked XRDs (i.e. moves it from the regular [stake_xrd_vault_id] to the [pending_xrd_withdraw_vault_id]), and then requires to claim the XRDs using this NFT after a delay (see [UnstakeData.claim_epoch]).

pending_xrd_withdraw_vault_id: Own

A vault holding the XRDs that were unstaked (see the [unstake_nft]) but not yet claimed.

locked_owner_stake_unit_vault_id: Own

A vault holding the SUs that this validator’s owner voluntarily decided to temporarily lock here, as a public display of their confidence in this validator’s future reliability. Withdrawing SUs from this vault is subject to a delay (which is configured separately from the regular unstaking delay, see [ConsensusManagerConfigSubstate.num_owner_stake_units_unlock_epochs]). This vault is private to the owner (i.e. the owner’s badge is required for any interaction with this vault).

pending_owner_stake_unit_unlock_vault_id: Own

A vault holding the SUs which the owner has decided to withdraw from their “public display” vault (see [locked_owner_stake_unit_vault_id]) but which have not yet been unlocked after the mandatory delay (see [pending_owner_stake_unit_withdrawals]).

pending_owner_stake_unit_withdrawals: BTreeMap<Epoch, Decimal>

All currently pending “delayed withdrawal” operations of the owner’s stake units vault (see [locked_owner_stake_unit_vault_id]). This maps an epoch number to an amount of stake units that become unlocked at that epoch. Note: because of performance considerations, a maximum size of this map is limited to OWNER_STAKE_UNITS_PENDING_WITHDRAWALS_LIMIT: starting another withdrawal will first attempt to move any already-available amount to [already_unlocked_owner_stake_unit_amount] and only then will fail if the limit is exceeded.

already_unlocked_owner_stake_unit_amount: Decimal

An amount of owner’s stake units that has already waited for a sufficient number of epochs in the [pending_owner_stake_unit_withdrawals] and was automatically moved from there. The very next [finish_unlock_owner_stake_units()] operation will release this amount.

Trait Implementations

impl Categorize<ScryptoCustomValueKind> for ValidatorSubstate

fn value_kind() -> ValueKind<ScryptoCustomValueKind>

impl Clone for ValidatorSubstate

fn clone(&self) -> ValidatorSubstate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ValidatorSubstate

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

Formats the value using the given formatter.

impl<D: Decoder<ScryptoCustomValueKind>> Decode<ScryptoCustomValueKind, D> for ValidatorSubstate

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ScryptoCustomValueKind> ) -> Result<Self, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl Describe<ScryptoCustomTypeKind> for ValidatorSubstate

const TYPE_ID: RustTypeId = _

The TYPE_ID should give a unique identifier for its SBOR schema type. An SBOR schema type capture details about the SBOR payload, how it should be interpreted, validated and displayed.

fn type_data() -> TypeData<ScryptoCustomTypeKind, RustTypeId>

Returns the local schema for the given type.

fn add_all_dependencies(aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>)

For each type referenced in get_local_type_data, we need to ensure that the type and all of its own references get added to the aggregator.

impl<E: Encoder<ScryptoCustomValueKind>> Encode<ScryptoCustomValueKind, E> for ValidatorSubstate

fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR value’s kind to the encoder

fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR body of the type to the encoder.

impl From<ValidatorSubstate> for VersionedValidatorState

fn from(value: ValidatorStateV1) -> Self

Converts to this type from the input type.

impl PartialEq for ValidatorSubstate

fn eq(&self, other: &ValidatorSubstate) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SborTuple<ScryptoCustomValueKind> for ValidatorSubstate

fn get_length(&self) -> usize

impl Eq for ValidatorSubstate

impl StructuralPartialEq for ValidatorSubstate