Module `sui_system::validator_set`

Struct ValidatorSet
Struct ValidatorEpochInfoEvent
Struct ValidatorEpochInfoEventV2
Struct ValidatorJoinEvent
Struct ValidatorLeaveEvent
Struct VotingPowerAdmissionStartEpochKey
Constants
Function new
Function request_add_validator_candidate
Function request_remove_validator_candidate
Function request_add_validator
Function can_join
Function get_voting_power_thresholds
Function assert_no_pending_or_active_duplicates
Function request_remove_validator
Function request_add_stake
Function request_withdraw_stake
Function convert_to_fungible_staked_sui
Function redeem_fungible_staked_sui
Function advance_epoch
Function update_validator_positions_and_calculate_total_stake
Function effectuate_staged_metadata
Function derive_reference_gas_price
Function total_stake
Function validator_total_stake_amount
Function validator_stake_amount
Function validator_voting_power
Function validator_staking_pool_id
Function staking_pool_mappings
Function validator_address_by_pool_id
Function pool_exchange_rates
Function validator_by_pool_id
Function next_epoch_validator_count
Function is_active_validator_by_sui_address
Function is_duplicate_with_active_validator
Function is_duplicate_validator
Function count_duplicates_vec
Function is_duplicate_with_pending_validator
Function count_duplicates_tablevec
Function get_candidate_or_active_validator_mut
Function find_validator
Function find_validator_from_table_vec
Function get_validator_indices
Function any_validator
Function any_validator_mut
Function active_validator
Function active_validator_mut
Function pending_validator
Function pending_validator_mut
Function candidate_validator
Function candidate_validator_mut
Function get_validator_ref
Function get_active_or_pending_or_candidate_validator_ref
Function verify_cap
Function process_pending_removals
Function process_validator_departure
Function clean_report_records_leaving_validator
Function sort_removal_list
Function process_pending_stakes_and_withdraws
Function calculate_total_stakes
Function adjust_stake_and_gas_price
Function compute_reward_adjustments
Function compute_slashed_validators
Function compute_unadjusted_reward_distribution
Function compute_adjusted_reward_distribution
Function distribute_reward
Function emit_validator_epoch_events
Function sum_voting_power_by_addresses
Function active_validators
Function is_validator_candidate
Function is_active_validator
Function is_inactive_validator
Function is_at_risk_validator
Function active_validator_addresses
Macro function mul_div
Function get_active_validator_ref
Function get_pending_validator_ref

<pre><code>use <a href="../std/address.md#std_address">std::address</a>; use <a href="../std/ascii.md#std_ascii">std::ascii</a>; use <a href="../std/bcs.md#std_bcs">std::bcs</a>; use <a href="../std/internal.md#std_internal">std::internal</a>; use <a href="../std/option.md#std_option">std::option</a>; use <a href="../std/string.md#std_string">std::string</a>; use <a href="../std/type_name.md#std_type_name">std::type_name</a>; use <a href="../std/u128.md#std_u128">std::u128</a>; use <a href="../std/u64.md#std_u64">std::u64</a>; use <a href="../std/vector.md#std_vector">std::vector</a>; use <a href="../sui/accumulator.md#sui_accumulator">sui::accumulator</a>; use <a href="../sui/accumulator_settlement.md#sui_accumulator_settlement">sui::accumulator_settlement</a>; use <a href="../sui/address.md#sui_address">sui::address</a>; use <a href="../sui/bag.md#sui_bag">sui::bag</a>; use <a href="../sui/balance.md#sui_balance">sui::balance</a>; use <a href="../sui/bcs.md#sui_bcs">sui::bcs</a>; use <a href="../sui/coin.md#sui_coin">sui::coin</a>; use <a href="../sui/config.md#sui_config">sui::config</a>; use <a href="../sui/deny_list.md#sui_deny_list">sui::deny_list</a>; use <a href="../sui/dynamic_field.md#sui_dynamic_field">sui::dynamic_field</a>; use <a href="../sui/dynamic_object_field.md#sui_dynamic_object_field">sui::dynamic_object_field</a>; use <a href="../sui/event.md#sui_event">sui::event</a>; use <a href="../sui/funds_accumulator.md#sui_funds_accumulator">sui::funds_accumulator</a>; use <a href="../sui/hash.md#sui_hash">sui::hash</a>; use <a href="../sui/hex.md#sui_hex">sui::hex</a>; use <a href="../sui/object.md#sui_object">sui::object</a>; use <a href="../sui/party.md#sui_party">sui::party</a>; use <a href="../sui/priority_queue.md#sui_priority_queue">sui::priority_queue</a>; use <a href="../sui/protocol_config.md#sui_protocol_config">sui::protocol_config</a>; use <a href="../sui/sui.md#sui_sui">sui::sui</a>; use <a href="../sui/table.md#sui_table">sui::table</a>; use <a href="../sui/table_vec.md#sui_table_vec">sui::table_vec</a>; use <a href="../sui/transfer.md#sui_transfer">sui::transfer</a>; use <a href="../sui/tx_context.md#sui_tx_context">sui::tx_context</a>; use <a href="../sui/types.md#sui_types">sui::types</a>; use <a href="../sui/url.md#sui_url">sui::url</a>; use <a href="../sui/vec_map.md#sui_vec_map">sui::vec_map</a>; use <a href="../sui/vec_set.md#sui_vec_set">sui::vec_set</a>; use <a href="../sui/versioned.md#sui_versioned">sui::versioned</a>; use <a href="../sui_system/staking_pool.md#sui_system_staking_pool">sui_system::staking_pool</a>; use <a href="../sui_system/validator.md#sui_system_validator">sui_system::validator</a>; use <a href="../sui_system/validator_cap.md#sui_system_validator_cap">sui_system::validator_cap</a>; use <a href="../sui_system/validator_wrapper.md#sui_system_validator_wrapper">sui_system::validator_wrapper</a>; use <a href="../sui_system/voting_power.md#sui_system_voting_power">sui_system::voting_power</a>; </code></pre>

Struct `ValidatorSet`

<pre><code>public struct <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a> has store </code></pre> <details> <summary>Fields</summary> <dl> <dt> <code><a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>: u64</code> </dt> <dd> Total amount of stake from all active validators at the beginning of the epoch. Written only once per epoch, in <code><a href="../sui_system/validator_set.md#sui_system_validator_set_advance_epoch">advance_epoch</a></code> function. </dd> <dt> <code><a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>: vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>></code> </dt> <dd> The current list of active validators. </dd> <dt> <code>pending_active_validators: <a href="../sui/table_vec.md#sui_table_vec_TableVec">sui::table_vec::TableVec</a><<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>></code> </dt> <dd> List of new validator candidates added during the current epoch. They will be processed at the end of the epoch. </dd> <dt> <code>pending_removals: vector<u64></code> </dt> <dd> Removal requests from the validators. Each element is an index pointing to <code><a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a></code>. </dd> <dt> <code><a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>: <a href="../sui/table.md#sui_table_Table">sui::table::Table</a><<a href="../sui/object.md#sui_object_ID">sui::object::ID</a>, address></code> </dt> <dd> Mappings from staking pool's ID to the sui address of a validator. </dd> <dt> <code>inactive_validators: <a href="../sui/table.md#sui_table_Table">sui::table::Table</a><<a href="../sui/object.md#sui_object_ID">sui::object::ID</a>, <a href="../sui_system/validator_wrapper.md#sui_system_validator_wrapper_ValidatorWrapper">sui_system::validator_wrapper::ValidatorWrapper</a>></code> </dt> <dd> Mapping from a staking pool ID to the inactive validator that has that pool as its staking pool. When a validator is deactivated the validator is removed from <code><a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a></code> it is added to this table so that stakers can continue to withdraw their stake from it. </dd> <dt> <code>validator_candidates: <a href="../sui/table.md#sui_table_Table">sui::table::Table</a><address, <a href="../sui_system/validator_wrapper.md#sui_system_validator_wrapper_ValidatorWrapper">sui_system::validator_wrapper::ValidatorWrapper</a>></code> </dt> <dd> Table storing preactive/candidate validators, mapping their addresses to their <code>Validator </code> structs. When an address calls <code><a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator_candidate">request_add_validator_candidate</a></code>, they get added to this table and become a preactive validator. When the candidate has met the min stake requirement, they can call <code><a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator">request_add_validator</a></code> to officially add them to the active validator set <code><a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a></code> next epoch. </dd> <dt> <code>at_risk_validators: <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, u64></code> </dt> <dd> Table storing the number of epochs during which a validator's stake has been below the low stake threshold. </dd> <dt> <code>extra_fields: <a href="../sui/bag.md#sui_bag_Bag">sui::bag::Bag</a></code> </dt> <dd> Any extra fields that's not defined statically. </dd> </dl> </details>

Struct `ValidatorEpochInfoEvent`

Event containing staking and rewards related information of each validator, emitted during epoch advancement.

<pre><code>public struct <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorEpochInfoEvent">ValidatorEpochInfoEvent</a> has copy, drop </code></pre> <details> <summary>Fields</summary> <dl> <dt> <code>epoch: u64</code> </dt> <dd> </dd> <dt> <code>validator_address: address</code> </dt> <dd> </dd> <dt> <code>reference_gas_survey_quote: u64</code> </dt> <dd> </dd> <dt> <code>stake: u64</code> </dt> <dd> </dd> <dt> <code>commission_rate: u64</code> </dt> <dd> </dd> <dt> <code>pool_staking_reward: u64</code> </dt> <dd> </dd> <dt> <code>storage_fund_staking_reward: u64</code> </dt> <dd> </dd> <dt> <code>pool_token_exchange_rate: <a href="../sui_system/staking_pool.md#sui_system_staking_pool_PoolTokenExchangeRate">sui_system::staking_pool::PoolTokenExchangeRate</a></code> </dt> <dd> </dd> <dt> <code>tallying_rule_reporters: vector<address></code> </dt> <dd> </dd> <dt> <code>tallying_rule_global_score: u64</code> </dt> <dd> </dd> </dl> </details>

Struct `ValidatorEpochInfoEventV2`

V2 of ValidatorEpochInfoEvent containing more information about the validator.

<pre><code>public struct <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorEpochInfoEventV2">ValidatorEpochInfoEventV2</a> has copy, drop </code></pre> <details> <summary>Fields</summary> <dl> <dt> <code>epoch: u64</code> </dt> <dd> </dd> <dt> <code>validator_address: address</code> </dt> <dd> </dd> <dt> <code>reference_gas_survey_quote: u64</code> </dt> <dd> </dd> <dt> <code>stake: u64</code> </dt> <dd> </dd> <dt> <code><a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>: u64</code> </dt> <dd> </dd> <dt> <code>commission_rate: u64</code> </dt> <dd> </dd> <dt> <code>pool_staking_reward: u64</code> </dt> <dd> </dd> <dt> <code>storage_fund_staking_reward: u64</code> </dt> <dd> </dd> <dt> <code>pool_token_exchange_rate: <a href="../sui_system/staking_pool.md#sui_system_staking_pool_PoolTokenExchangeRate">sui_system::staking_pool::PoolTokenExchangeRate</a></code> </dt> <dd> </dd> <dt> <code>tallying_rule_reporters: vector<address></code> </dt> <dd> </dd> <dt> <code>tallying_rule_global_score: u64</code> </dt> <dd> </dd> </dl> </details>

Struct `ValidatorJoinEvent`

Event emitted every time a new validator joins the committee. The epoch value corresponds to the first epoch this change takes place.

<pre><code>public struct <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorJoinEvent">ValidatorJoinEvent</a> has copy, drop </code></pre> <details> <summary>Fields</summary> <dl> <dt> <code>epoch: u64</code> </dt> <dd> </dd> <dt> <code>validator_address: address</code> </dt> <dd> </dd> <dt> <code>staking_pool_id: <a href="../sui/object.md#sui_object_ID">sui::object::ID</a></code> </dt> <dd> </dd> </dl> </details>

Struct `ValidatorLeaveEvent`

Event emitted every time a validator leaves the committee. The epoch value corresponds to the first epoch this change takes place.

<pre><code>public struct <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorLeaveEvent">ValidatorLeaveEvent</a> has copy, drop </code></pre> <details> <summary>Fields</summary> <dl> <dt> <code>epoch: u64</code> </dt> <dd> </dd> <dt> <code>validator_address: address</code> </dt> <dd> </dd> <dt> <code>staking_pool_id: <a href="../sui/object.md#sui_object_ID">sui::object::ID</a></code> </dt> <dd> </dd> <dt> <code>is_voluntary: bool</code> </dt> <dd> </dd> </dl> </details>

Struct `VotingPowerAdmissionStartEpochKey`

Key for the <code>extra_fields</code> bag to store the start epoch of allowing admission of new validators based on a minimum voting power rather than a minimum stake.

<pre><code>public struct <a href="../sui_system/validator_set.md#sui_system_validator_set_VotingPowerAdmissionStartEpochKey">VotingPowerAdmissionStartEpochKey</a> has copy, drop, store </code></pre> <details> <summary>Fields</summary> <dl> </dl> </details>

Constants

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ENonValidatorInReportRecords">ENonValidatorInReportRecords</a>: u64 = 0; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EInvalidStakeAdjustmentAmount">EInvalidStakeAdjustmentAmount</a>: u64 = 1; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EDuplicateValidator">EDuplicateValidator</a>: u64 = 2; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ENoPoolFound">ENoPoolFound</a>: u64 = 3; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAValidator">ENotAValidator</a>: u64 = 4; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EMinJoiningStakeNotReached">EMinJoiningStakeNotReached</a>: u64 = 5; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EAlreadyValidatorCandidate">EAlreadyValidatorCandidate</a>: u64 = 6; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorNotCandidate">EValidatorNotCandidate</a>: u64 = 7; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotValidatorCandidate">ENotValidatorCandidate</a>: u64 = 8; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EStakingBelowThreshold">EStakingBelowThreshold</a>: u64 = 10; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorAlreadyRemoved">EValidatorAlreadyRemoved</a>: u64 = 11; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAPendingValidator">ENotAPendingValidator</a>: u64 = 12; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorSetEmpty">EValidatorSetEmpty</a>: u64 = 13; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EInvalidCap">EInvalidCap</a>: u64 = 101; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_EInvalidValidatorSelector">EInvalidValidatorSelector</a>: u64 = 14; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ACTIVE_VALIDATOR_ONLY">ACTIVE_VALIDATOR_ONLY</a>: u8 = 1; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ACTIVE_OR_PENDING_VALIDATOR">ACTIVE_OR_PENDING_VALIDATOR</a>: u8 = 2; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_ANY_VALIDATOR">ANY_VALIDATOR</a>: u8 = 3; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_BASIS_POINT_DENOMINATOR">BASIS_POINT_DENOMINATOR</a>: u64 = 10000; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_MIN_STAKING_THRESHOLD">MIN_STAKING_THRESHOLD</a>: u64 = 1000000000; </code></pre>

<pre><code>const <a href="../sui_system/validator_set.md#sui_system_validator_set_PHASE_LENGTH">PHASE_LENGTH</a>: u64 = 14; </code></pre>

Function `new`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_new">new</a>(init_active_validators: vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_new">new</a>( init_active_validators: vector<Validator>, ctx: &mut TxContext, ): <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a> { let <a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a> = <a href="../sui_system/validator_set.md#sui_system_validator_set_calculate_total_stakes">calculate_total_stakes</a>(&init_active_validators); let mut <a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a> = table::new(ctx); init_active_validators.do_ref!(|v| { <a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.add(v.staking_pool_id(), v.sui_address()); }); let mut validators = <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a> { <a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>, <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>: init_active_validators, pending_active_validators: table_vec::empty(ctx), pending_removals: vector[], <a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>, inactive_validators: table::new(ctx), validator_candidates: table::new(ctx), at_risk_validators: vec_map::empty(), extra_fields: bag::new(ctx), }; <a href="../sui_system/voting_power.md#sui_system_voting_power_set_voting_power">voting_power::set_voting_power</a>(&mut validators.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, <a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>); validators } </code></pre> </details>

Function `request_add_validator_candidate`

Called by <code><a href="../sui_system/sui_system.md#sui_system_sui_system">sui_system</a></code> to add a new validator candidate.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator_candidate">request_add_validator_candidate</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: <a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator_candidate">request_add_validator_candidate</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: Validator, ctx: &mut TxContext, ) { // The next assertions are not critical for the protocol, but they are here to catch problematic configs earlier. assert!( !self.<a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_active_validator">is_duplicate_with_active_validator</a>(&<a href="../sui_system/validator.md#sui_system_validator">validator</a>) && !self.<a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_pending_validator">is_duplicate_with_pending_validator</a>(&<a href="../sui_system/validator.md#sui_system_validator">validator</a>), <a href="../sui_system/validator_set.md#sui_system_validator_set_EDuplicateValidator">EDuplicateValidator</a>, ); let validator_address = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.sui_address(); assert!(!self.validator_candidates.contains(validator_address), <a href="../sui_system/validator_set.md#sui_system_validator_set_EAlreadyValidatorCandidate">EAlreadyValidatorCandidate</a>); assert!(<a href="../sui_system/validator.md#sui_system_validator">validator</a>.is_preactive(), <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorNotCandidate">EValidatorNotCandidate</a>); // Add <a href="../sui_system/validator.md#sui_system_validator">validator</a> to the candidates mapping and the pool id mappings so that users can start // staking with this candidate. self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.add(<a href="../sui_system/validator.md#sui_system_validator">validator</a>.staking_pool_id(), validator_address); self.validator_candidates.add(<a href="../sui_system/validator.md#sui_system_validator">validator</a>.sui_address(), <a href="../sui_system/validator.md#sui_system_validator">validator</a>.wrap_v1(ctx)); } </code></pre> </details>

Function `request_remove_validator_candidate`

Called by <code><a href="../sui_system/sui_system.md#sui_system_sui_system">sui_system</a></code> to remove a validator candidate, and move them to <code>inactive_validators</code>.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_remove_validator_candidate">request_remove_validator_candidate</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_remove_validator_candidate">request_remove_validator_candidate</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, ctx: &mut TxContext, ) { let validator_address = ctx.sender(); assert!(self.validator_candidates.contains(validator_address), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotValidatorCandidate">ENotValidatorCandidate</a>); let mut <a href="../sui_system/validator.md#sui_system_validator">validator</a> = self.validator_candidates.remove(validator_address).destroy(); assert!(<a href="../sui_system/validator.md#sui_system_validator">validator</a>.is_preactive(), <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorNotCandidate">EValidatorNotCandidate</a>); let staking_pool_id = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.staking_pool_id(); // Remove the <a href="../sui_system/validator.md#sui_system_validator">validator</a>'s staking pool from mappings. self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.remove(staking_pool_id); // Deactivate the staking pool. <a href="../sui_system/validator.md#sui_system_validator">validator</a>.deactivate(ctx.epoch()); // Add to the inactive tables. self.inactive_validators.add(staking_pool_id, <a href="../sui_system/validator.md#sui_system_validator">validator</a>.wrap_v1(ctx)); } </code></pre> </details>

Function `request_add_validator`

Called by <code><a href="../sui_system/sui_system.md#sui_system_sui_system">sui_system</a></code> to add a new validator to <code>pending_active_validators</code>, which will be processed at the end of epoch.

Aborts if the validator contains duplicate metadata values with an active or pending validator.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator">request_add_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, ctx: &<a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator">request_add_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, ctx: &TxContext) { let validator_address = ctx.sender(); assert!(self.validator_candidates.contains(validator_address), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotValidatorCandidate">ENotValidatorCandidate</a>); let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = self.validator_candidates.remove(validator_address).destroy(); assert!( !self.<a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_active_validator">is_duplicate_with_active_validator</a>(&<a href="../sui_system/validator.md#sui_system_validator">validator</a>) && !self.<a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_pending_validator">is_duplicate_with_pending_validator</a>(&<a href="../sui_system/validator.md#sui_system_validator">validator</a>), <a href="../sui_system/validator_set.md#sui_system_validator_set_EDuplicateValidator">EDuplicateValidator</a>, ); assert!(<a href="../sui_system/validator.md#sui_system_validator">validator</a>.is_preactive(), <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorNotCandidate">EValidatorNotCandidate</a>); assert!(self.<a href="../sui_system/validator_set.md#sui_system_validator_set_can_join">can_join</a>(<a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>(), ctx), <a href="../sui_system/validator_set.md#sui_system_validator_set_EMinJoiningStakeNotReached">EMinJoiningStakeNotReached</a>); self.pending_active_validators.push_back(<a href="../sui_system/validator.md#sui_system_validator">validator</a>); } </code></pre> </details>

Function `can_join`

Return <code>true</code> if a candidate validator with <code>stake</code> will have sufficeint voting power to join the validator set

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_can_join">can_join</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, stake: u64, ctx: &<a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_can_join">can_join</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, stake: u64, ctx: &TxContext): bool { let (min_joining_voting_power, _, _) = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_get_voting_power_thresholds">get_voting_power_thresholds</a>(ctx); // if the <a href="../sui_system/validator.md#sui_system_validator">validator</a> will have at least `min_joining_voting_power` after joining, they can join. // this formula comes from SIP-39: https://github.com/sui-foundation/sips/blob/main/sips/sip-39.md let future_total_stake = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a> + stake; let future_validator_voting_power = <a href="../sui_system/voting_power.md#sui_system_voting_power_derive_raw_voting_power">voting_power::derive_raw_voting_power</a>( stake, future_total_stake, ); future_validator_voting_power >= min_joining_voting_power } </code></pre> </details>

Function `get_voting_power_thresholds`

return (min, low, very low voting power) thresholds

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_voting_power_thresholds">get_voting_power_thresholds</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, ctx: &<a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): (u64, u64, u64) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_voting_power_thresholds">get_voting_power_thresholds</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, ctx: &TxContext): (u64, u64, u64) { let start_epoch = { let key = <a href="../sui_system/validator_set.md#sui_system_validator_set_VotingPowerAdmissionStartEpochKey">VotingPowerAdmissionStartEpochKey</a>(); if (self.extra_fields.contains(key)) self.extra_fields[key] else ctx.epoch() + 1 // will give us the phase 1 values }; // these numbers come from SIP-39: https://github.com/sui-foundation/sips/blob/main/sips/sip-39.md let curr_epoch = ctx.epoch(); if (curr_epoch < start_epoch + <a href="../sui_system/validator_set.md#sui_system_validator_set_PHASE_LENGTH">PHASE_LENGTH</a>) (12, 8, 4) // phase 1 else if (curr_epoch < start_epoch + (2 * <a href="../sui_system/validator_set.md#sui_system_validator_set_PHASE_LENGTH">PHASE_LENGTH</a>)) (6, 4, 2) // phase 2 else (3, 2, 1) // phase 3 } </code></pre> </details>

Function `assert_no_pending_or_active_duplicates`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_assert_no_pending_or_active_duplicates">assert_no_pending_or_active_duplicates</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_assert_no_pending_or_active_duplicates">assert_no_pending_or_active_duplicates</a>( self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: &Validator, ) { // Validator here must be active or pending, and thus must be identified as duplicate exactly once. assert!( <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_vec">count_duplicates_vec</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>) + <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_tablevec">count_duplicates_tablevec</a>(&self.pending_active_validators, <a href="../sui_system/validator.md#sui_system_validator">validator</a>) == 1, <a href="../sui_system/validator_set.md#sui_system_validator_set_EDuplicateValidator">EDuplicateValidator</a>, ); } </code></pre> </details>

Function `request_remove_validator`

Called by <code><a href="../sui_system/sui_system.md#sui_system_sui_system">sui_system</a></code>, to remove a validator. The index of the validator is added to <code>pending_removals</code> and will be processed at the end of epoch. Only an active validator can request to be removed.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_remove_validator">request_remove_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, ctx: &<a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_remove_validator">request_remove_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, ctx: &TxContext) { let validator_address = ctx.sender(); let validator_index = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>( &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, validator_address, ).destroy_or!(abort <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAValidator">ENotAValidator</a>); assert!(!self.pending_removals.contains(&validator_index), <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorAlreadyRemoved">EValidatorAlreadyRemoved</a>); self.pending_removals.push_back(validator_index); } </code></pre> </details>

Function `request_add_stake`

Called by <code><a href="../sui_system/sui_system.md#sui_system_sui_system">sui_system</a></code>, to add a new stake to the validator. This request is added to the validator's staking pool's pending stake entries, processed at the end of the epoch. Aborts in case the staking amount is smaller than MIN_STAKING_THRESHOLD

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_stake">request_add_stake</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address, stake: <a href="../sui/balance.md#sui_balance_Balance">sui::balance::Balance</a><<a href="../sui/sui.md#sui_sui_SUI">sui::sui::SUI</a>>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): <a href="../sui_system/staking_pool.md#sui_system_staking_pool_StakedSui">sui_system::staking_pool::StakedSui</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_stake">request_add_stake</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address, stake: Balance<SUI>, ctx: &mut TxContext, ): StakedSui { let sui_amount = stake.value(); assert!(sui_amount >= <a href="../sui_system/validator_set.md#sui_system_validator_set_MIN_STAKING_THRESHOLD">MIN_STAKING_THRESHOLD</a>, <a href="../sui_system/validator_set.md#sui_system_validator_set_EStakingBelowThreshold">EStakingBelowThreshold</a>); self .<a href="../sui_system/validator_set.md#sui_system_validator_set_get_candidate_or_active_validator_mut">get_candidate_or_active_validator_mut</a>(validator_address) .<a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_stake">request_add_stake</a>(stake, ctx.sender(), ctx) } </code></pre> </details>

Function `request_withdraw_stake`

Called by <code><a href="../sui_system/sui_system.md#sui_system_sui_system">sui_system</a></code>, to withdraw some share of a stake from the validator. The share to withdraw is denoted by <code>principal_withdraw_amount</code>. One of two things occurs in this function:

If the <code>staked_sui</code> is staked with an active validator, the request is added to the validator's staking pool's pending stake withdraw entries, processed at the end of the epoch.
If the <code>staked_sui</code> was staked with a validator that is no longer active, the stake and any rewards corresponding to it will be immediately processed.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_withdraw_stake">request_withdraw_stake</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, staked_sui: <a href="../sui_system/staking_pool.md#sui_system_staking_pool_StakedSui">sui_system::staking_pool::StakedSui</a>, ctx: &<a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): <a href="../sui/balance.md#sui_balance_Balance">sui::balance::Balance</a><<a href="../sui/sui.md#sui_sui_SUI">sui::sui::SUI</a>> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_request_withdraw_stake">request_withdraw_stake</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, staked_sui: StakedSui, ctx: &TxContext, ): Balance<SUI> { let staking_pool_id = staked_sui.pool_id(); let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = if (self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.contains(staking_pool_id)) { // This is an active <a href="../sui_system/validator.md#sui_system_validator">validator</a>. let validator_address = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>[staked_sui.pool_id()]; self.<a href="../sui_system/validator_set.md#sui_system_validator_set_get_candidate_or_active_validator_mut">get_candidate_or_active_validator_mut</a>(validator_address) } else { // This is an inactive pool. assert!(self.inactive_validators.contains(staking_pool_id), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENoPoolFound">ENoPoolFound</a>); self.inactive_validators[staking_pool_id].load_validator_maybe_upgrade() }; <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/validator_set.md#sui_system_validator_set_request_withdraw_stake">request_withdraw_stake</a>(staked_sui, ctx) } </code></pre> </details>

Function `convert_to_fungible_staked_sui`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_convert_to_fungible_staked_sui">convert_to_fungible_staked_sui</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, staked_sui: <a href="../sui_system/staking_pool.md#sui_system_staking_pool_StakedSui">sui_system::staking_pool::StakedSui</a>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): <a href="../sui_system/staking_pool.md#sui_system_staking_pool_FungibleStakedSui">sui_system::staking_pool::FungibleStakedSui</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_convert_to_fungible_staked_sui">convert_to_fungible_staked_sui</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, staked_sui: StakedSui, ctx: &mut TxContext, ): FungibleStakedSui { let staking_pool_id = staked_sui.pool_id(); let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = if (self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.contains(staking_pool_id)) { // This is an active <a href="../sui_system/validator.md#sui_system_validator">validator</a>. let validator_address = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>[staking_pool_id]; self.<a href="../sui_system/validator_set.md#sui_system_validator_set_get_candidate_or_active_validator_mut">get_candidate_or_active_validator_mut</a>(validator_address) } else { // This is an inactive pool. assert!(self.inactive_validators.contains(staking_pool_id), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENoPoolFound">ENoPoolFound</a>); self.inactive_validators[staking_pool_id].load_validator_maybe_upgrade() }; <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/validator_set.md#sui_system_validator_set_convert_to_fungible_staked_sui">convert_to_fungible_staked_sui</a>(staked_sui, ctx) } </code></pre> </details>

Function `redeem_fungible_staked_sui`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_redeem_fungible_staked_sui">redeem_fungible_staked_sui</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, fungible_staked_sui: <a href="../sui_system/staking_pool.md#sui_system_staking_pool_FungibleStakedSui">sui_system::staking_pool::FungibleStakedSui</a>, ctx: &<a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): <a href="../sui/balance.md#sui_balance_Balance">sui::balance::Balance</a><<a href="../sui/sui.md#sui_sui_SUI">sui::sui::SUI</a>> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_redeem_fungible_staked_sui">redeem_fungible_staked_sui</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, fungible_staked_sui: FungibleStakedSui, ctx: &TxContext, ): Balance<SUI> { let staking_pool_id = fungible_staked_sui.pool_id(); let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = if (self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.contains(staking_pool_id)) { // This is an active <a href="../sui_system/validator.md#sui_system_validator">validator</a>. let validator_address = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>[staking_pool_id]; self.<a href="../sui_system/validator_set.md#sui_system_validator_set_get_candidate_or_active_validator_mut">get_candidate_or_active_validator_mut</a>(validator_address) } else { // This is an inactive pool. assert!(self.inactive_validators.contains(staking_pool_id), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENoPoolFound">ENoPoolFound</a>); self.inactive_validators[staking_pool_id].load_validator_maybe_upgrade() }; <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/validator_set.md#sui_system_validator_set_redeem_fungible_staked_sui">redeem_fungible_staked_sui</a>(fungible_staked_sui, ctx) } </code></pre> </details>

Function `advance_epoch`

Update the validator set at the end of epoch. It does the following things:

Distribute stake award.
Process pending stake deposits and withdraws for each validator (<code>adjust_stake</code>).
Process pending stake deposits, and withdraws.
Process pending validator application and withdraws.
At the end, we calculate the total stake for the new epoch.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_advance_epoch">advance_epoch</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, computation_reward: &mut <a href="../sui/balance.md#sui_balance_Balance">sui::balance::Balance</a><<a href="../sui/sui.md#sui_sui_SUI">sui::sui::SUI</a>>, storage_fund_reward: &mut <a href="../sui/balance.md#sui_balance_Balance">sui::balance::Balance</a><<a href="../sui/sui.md#sui_sui_SUI">sui::sui::SUI</a>>, validator_report_records: &mut <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, <a href="../sui/vec_set.md#sui_vec_set_VecSet">sui::vec_set::VecSet</a><address>>, reward_slashing_rate: u64, low_stake_grace_period: u64, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_advance_epoch">advance_epoch</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, computation_reward: &mut Balance<SUI>, storage_fund_reward: &mut Balance<SUI>, validator_report_records: &mut VecMap<address, VecSet<address>>, reward_slashing_rate: u64, low_stake_grace_period: u64, ctx: &mut TxContext, ) { let new_epoch = ctx.epoch() + 1; let total_voting_power = <a href="../sui_system/voting_power.md#sui_system_voting_power_total_voting_power">voting_power::total_voting_power</a>(); // switch to using voting power based admission, if we are not already using it let key = <a href="../sui_system/validator_set.md#sui_system_validator_set_VotingPowerAdmissionStartEpochKey">VotingPowerAdmissionStartEpochKey</a>(); if (!self.extra_fields.contains(key)) self.extra_fields.add(key, ctx.epoch()); // Compute the reward distribution without taking into account the tallying rule slashing. let ( unadjusted_staking_reward_amounts, unadjusted_storage_fund_reward_amounts, ) = <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_unadjusted_reward_distribution">compute_unadjusted_reward_distribution</a>( &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, total_voting_power, computation_reward.value(), storage_fund_reward.value(), ); // Use the tallying rule report records for the epoch to compute validators that will be // punished. let slashed_validators = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_compute_slashed_validators">compute_slashed_validators</a>(*validator_report_records); let total_slashed_validator_voting_power = <a href="../sui_system/validator_set.md#sui_system_validator_set_sum_voting_power_by_addresses">sum_voting_power_by_addresses</a>( &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, &slashed_validators, ); // Compute the reward adjustments of slashed validators, to be taken into // account in adjusted reward computation. let ( total_staking_reward_adjustment, individual_staking_reward_adjustments, total_storage_fund_reward_adjustment, individual_storage_fund_reward_adjustments, ) = <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_reward_adjustments">compute_reward_adjustments</a>( <a href="../sui_system/validator_set.md#sui_system_validator_set_get_validator_indices">get_validator_indices</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, &slashed_validators), reward_slashing_rate, &unadjusted_staking_reward_amounts, &unadjusted_storage_fund_reward_amounts, ); // Compute the adjusted amounts of stake each <a href="../sui_system/validator.md#sui_system_validator">validator</a> should get given the tallying rule // reward adjustments we computed before. // `<a href="../sui_system/validator_set.md#sui_system_validator_set_compute_adjusted_reward_distribution">compute_adjusted_reward_distribution</a>` must be called before `<a href="../sui_system/validator_set.md#sui_system_validator_set_distribute_reward">distribute_reward</a>` and `<a href="../sui_system/validator_set.md#sui_system_validator_set_adjust_stake_and_gas_price">adjust_stake_and_gas_price</a>` to // make sure we are using the current epoch's stake information to compute reward distribution. let ( adjusted_staking_reward_amounts, adjusted_storage_fund_reward_amounts, ) = <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_adjusted_reward_distribution">compute_adjusted_reward_distribution</a>( &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, total_voting_power, total_slashed_validator_voting_power, unadjusted_staking_reward_amounts, unadjusted_storage_fund_reward_amounts, total_staking_reward_adjustment, individual_staking_reward_adjustments, total_storage_fund_reward_adjustment, individual_storage_fund_reward_adjustments, ); // Distribute the rewards before adjusting stake so that we immediately start compounding // the rewards for validators and stakers. <a href="../sui_system/validator_set.md#sui_system_validator_set_distribute_reward">distribute_reward</a>( &mut self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, &adjusted_staking_reward_amounts, &adjusted_storage_fund_reward_amounts, computation_reward, storage_fund_reward, ctx, ); <a href="../sui_system/validator_set.md#sui_system_validator_set_adjust_stake_and_gas_price">adjust_stake_and_gas_price</a>(&mut self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>); <a href="../sui_system/validator_set.md#sui_system_validator_set_process_pending_stakes_and_withdraws">process_pending_stakes_and_withdraws</a>(&mut self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, ctx); // Emit events after we have processed all the rewards distribution and pending stakes. <a href="../sui_system/validator_set.md#sui_system_validator_set_emit_validator_epoch_events">emit_validator_epoch_events</a>( new_epoch, &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, &adjusted_staking_reward_amounts, &adjusted_storage_fund_reward_amounts, validator_report_records, &slashed_validators, ); self.<a href="../sui_system/validator_set.md#sui_system_validator_set_process_pending_removals">process_pending_removals</a>(validator_report_records, ctx); // kick low stake validators out. let new_total_stake = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_update_validator_positions_and_calculate_total_stake">update_validator_positions_and_calculate_total_stake</a>( low_stake_grace_period, validator_report_records, ctx, ); self.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a> = new_total_stake; <a href="../sui_system/voting_power.md#sui_system_voting_power_set_voting_power">voting_power::set_voting_power</a>(&mut self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, new_total_stake); // At this point, self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a> are updated for next epoch. // Now we process the staged <a href="../sui_system/validator.md#sui_system_validator">validator</a> metadata. self.<a href="../sui_system/validator_set.md#sui_system_validator_set_effectuate_staged_metadata">effectuate_staged_metadata</a>(); } </code></pre> </details>

Function `update_validator_positions_and_calculate_total_stake`

This function does the following:

removes validators from <code>at_risk</code> group if their voting power is above the LOW threshold
increments the number of epochs a validator has been below the LOW threshold but above the VERY LOW threshold
removes validators from the active set if they have been below the LOW threshold for more than <code>low_stake_grace_period</code> epochs
removes validators from the active set immediately if they are below the VERY LOW threshold
activates pending validators if they have sufficient voting power

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_update_validator_positions_and_calculate_total_stake">update_validator_positions_and_calculate_total_stake</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, low_stake_grace_period: u64, validator_report_records: &mut <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, <a href="../sui/vec_set.md#sui_vec_set_VecSet">sui::vec_set::VecSet</a><address>>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_update_validator_positions_and_calculate_total_stake">update_validator_positions_and_calculate_total_stake</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, low_stake_grace_period: u64, validator_report_records: &mut VecMap<address, VecSet<address>>, ctx: &mut TxContext, ): u64 { // take all pending validators out of the tablevec and put them in a local vector let pending_active_validators = vector::tabulate!( self.pending_active_validators.length(), |_| self.pending_active_validators.pop_back(), ); // Note: we count the total stake of pending validators as well! let pending_total_stake = <a href="../sui_system/validator_set.md#sui_system_validator_set_calculate_total_stakes">calculate_total_stakes</a>(&pending_active_validators); let initial_total_stake = <a href="../sui_system/validator_set.md#sui_system_validator_set_calculate_total_stakes">calculate_total_stakes</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>) + pending_total_stake; let ( min_joining_voting_power_threshold, low_voting_power_threshold, very_low_voting_power_threshold, ) = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_get_voting_power_thresholds">get_voting_power_thresholds</a>(ctx); // Iterate through all the active validators, record their low stake status, and kick them out if the condition is met. let mut total_removed_stake = 0; // amount of stake to remove due to departed_validators let mut i = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.length(); while (i > 0) { i = i - 1; let validator_ref = &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>[i]; let validator_address = validator_ref.sui_address(); let validator_stake = validator_ref.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>(); // calculate the voting power for this <a href="../sui_system/validator.md#sui_system_validator">validator</a> in the next epoch if no validators are removed // if one of more low stake validators are removed, it's possible this <a href="../sui_system/validator.md#sui_system_validator">validator</a> will have higher voting power--that's ok. let <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a> = <a href="../sui_system/voting_power.md#sui_system_voting_power_derive_raw_voting_power">voting_power::derive_raw_voting_power</a>( validator_stake, initial_total_stake, ); // SIP-39: a <a href="../sui_system/validator.md#sui_system_validator">validator</a> can remain indefinitely with a voting power ≥ LOW_VOTING_POWER_THRESHOLD if (<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a> >= low_voting_power_threshold) { // The <a href="../sui_system/validator.md#sui_system_validator">validator</a> is safe. We remove their entry from the at_risk map if there exists one. if (self.at_risk_validators.contains(&validator_address)) { self.at_risk_validators.remove(&validator_address); } // SIP-39: as soon as the <a href="../sui_system/validator.md#sui_system_validator">validator</a>’s voting power falls to VERY_LOW_VOTING_POWER_THRESHOLD, // they are on probation and must acquire sufficient stake to recover to voting power } else if (<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a> >= very_low_voting_power_threshold) { // The stake is a bit below the threshold so we increment the entry of the <a href="../sui_system/validator.md#sui_system_validator">validator</a> in the map. let new_low_stake_period = if (self.at_risk_validators.contains(&validator_address)) { let num_epochs = &mut self.at_risk_validators[&validator_address]; *num_epochs = *num_epochs + 1; *num_epochs } else { self.at_risk_validators.insert(validator_address, 1); 1 }; // If the grace period has passed, the <a href="../sui_system/validator.md#sui_system_validator">validator</a> has to leave us. if (new_low_stake_period > low_stake_grace_period) { let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.remove(i); let removed_stake = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_process_validator_departure">process_validator_departure</a>( <a href="../sui_system/validator.md#sui_system_validator">validator</a>, validator_report_records, false, // the <a href="../sui_system/validator.md#sui_system_validator">validator</a> is kicked out involuntarily ctx, ); total_removed_stake = total_removed_stake + removed_stake; } // SIP-39: at the end of an epoch when <a href="../sui_system/validator_set.md#sui_system_validator_set_new">new</a> voting powers are computed based on stake changes, // any <a href="../sui_system/validator.md#sui_system_validator">validator</a> with VOTING_POWER < VERY_LOW_VOTING_POWER_THRESHOLD will be removed } else { // The <a href="../sui_system/validator.md#sui_system_validator">validator</a>'s stake is lower than the very low threshold so we kick them out immediately. let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.remove(i); let removed_stake = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_process_validator_departure">process_validator_departure</a>( <a href="../sui_system/validator.md#sui_system_validator">validator</a>, validator_report_records, false, // the <a href="../sui_system/validator.md#sui_system_validator">validator</a> is kicked out involuntarily ctx, ); total_removed_stake = total_removed_stake + removed_stake; } }; // check that pending validators still have sufficient stake to be added. this was checked at // the time of <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator">request_add_validator</a>, but stake may have been withdrawn, or stakes of other // validators may have increased significantly pending_active_validators.do!(|mut <a href="../sui_system/validator.md#sui_system_validator">validator</a>| { let validator_stake = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>(); let <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a> = <a href="../sui_system/voting_power.md#sui_system_voting_power_derive_raw_voting_power">voting_power::derive_raw_voting_power</a>( validator_stake, initial_total_stake, ); if (<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a> >= min_joining_voting_power_threshold) { <a href="../sui_system/validator.md#sui_system_validator">validator</a>.activate(ctx.epoch()); event::emit(<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorJoinEvent">ValidatorJoinEvent</a> { epoch: ctx.epoch(), validator_address: <a href="../sui_system/validator.md#sui_system_validator">validator</a>.sui_address(), staking_pool_id: <a href="../sui_system/validator.md#sui_system_validator">validator</a>.staking_pool_id(), }); self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.push_back(<a href="../sui_system/validator.md#sui_system_validator">validator</a>); } else { // return <a href="../sui_system/validator.md#sui_system_validator">validator</a> object to the candidate pool. want to do this directly instead of // calling <a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_validator_candidate">request_add_validator_candidate</a> because <a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a> already has an // entry for this <a href="../sui_system/validator.md#sui_system_validator">validator</a>, and the duplicate checks are redundant self .validator_candidates .add( <a href="../sui_system/validator.md#sui_system_validator">validator</a>.sui_address(), <a href="../sui_system/validator.md#sui_system_validator">validator</a>.wrap_v1(ctx), ); total_removed_stake = total_removed_stake + validator_stake; } }); // <a href="../sui_system/validator_set.md#sui_system_validator_set_new">new</a> total stake is the initial total minus the amount removed via validators we kicked out initial_total_stake - total_removed_stake } </code></pre> </details>

Function `effectuate_staged_metadata`

Effectuate pending next epoch metadata if they are staged.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_effectuate_staged_metadata">effectuate_staged_metadata</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_effectuate_staged_metadata">effectuate_staged_metadata</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>) { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.do_mut!(|v| v.<a href="../sui_system/validator_set.md#sui_system_validator_set_effectuate_staged_metadata">effectuate_staged_metadata</a>()); } </code></pre> </details>

Function `derive_reference_gas_price`

Called by <code><a href="../sui_system/sui_system.md#sui_system_sui_system">sui_system</a></code> to derive reference gas price for the new epoch. Derive the reference gas price based on the gas price quote submitted by each validator. The returned gas price should be greater than or equal to 2/3 of the validators submitted gas price, weighted by stake.

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_derive_reference_gas_price">derive_reference_gas_price</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_derive_reference_gas_price">derive_reference_gas_price</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>): u64 { let entries = self .<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a> .map_ref!(|v| pq::new_entry(v.gas_price(), v.<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>())); // Build a priority queue that will pop entries with gas price from the highest to the lowest. let mut pq = pq::new(entries); let mut sum = 0; let threshold = <a href="../sui_system/voting_power.md#sui_system_voting_power_total_voting_power">voting_power::total_voting_power</a>() - <a href="../sui_system/voting_power.md#sui_system_voting_power_quorum_threshold">voting_power::quorum_threshold</a>(); let mut result = 0; while (sum < threshold) { let (gas_price, <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>) = pq.pop_max(); result = gas_price; sum = sum + <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>; }; result } </code></pre> </details>

Function `total_stake`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>): u64 { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a> } </code></pre> </details>

Function `validator_total_stake_amount`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_total_stake_amount">validator_total_stake_amount</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_total_stake_amount">validator_total_stake_amount</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address): u64 { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator">active_validator</a>(validator_address).<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>() } </code></pre> </details>

Function `validator_stake_amount`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_stake_amount">validator_stake_amount</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_stake_amount">validator_stake_amount</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address): u64 { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator">active_validator</a>(validator_address).<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>() } </code></pre> </details>

Function `validator_voting_power`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_voting_power">validator_voting_power</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_voting_power">validator_voting_power</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address): u64 { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator">active_validator</a>(validator_address).<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>() } </code></pre> </details>

Function `validator_staking_pool_id`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_staking_pool_id">validator_staking_pool_id</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address): <a href="../sui/object.md#sui_object_ID">sui::object::ID</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_staking_pool_id">validator_staking_pool_id</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address): ID { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator">active_validator</a>(validator_address).staking_pool_id() } </code></pre> </details>

Function `staking_pool_mappings`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>): &<a href="../sui/table.md#sui_table_Table">sui::table::Table</a><<a href="../sui/object.md#sui_object_ID">sui::object::ID</a>, address> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>): &Table<ID, address> { &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a> } </code></pre> </details>

Function `validator_address_by_pool_id`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_address_by_pool_id">validator_address_by_pool_id</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, pool_id: &<a href="../sui/object.md#sui_object_ID">sui::object::ID</a>): address </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_address_by_pool_id">validator_address_by_pool_id</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, pool_id: &ID): address { // If the pool id is recorded in the mapping, then it must be either candidate or active. if (self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.contains(*pool_id)) { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>[*pool_id] } else { // otherwise it's inactive self.inactive_validators[*pool_id].load_validator_maybe_upgrade().sui_address() } } </code></pre> </details>

Function `pool_exchange_rates`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_pool_exchange_rates">pool_exchange_rates</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, pool_id: <a href="../sui/object.md#sui_object_ID">sui::object::ID</a>): &<a href="../sui/table.md#sui_table_Table">sui::table::Table</a><u64, <a href="../sui_system/staking_pool.md#sui_system_staking_pool_PoolTokenExchangeRate">sui_system::staking_pool::PoolTokenExchangeRate</a>> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_pool_exchange_rates">pool_exchange_rates</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, pool_id: ID, ): &Table<u64, PoolTokenExchangeRate> { // If the pool id is recorded in the mapping, then it must be either candidate or active. let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = if (self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.contains(pool_id)) { let validator_address = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>[pool_id]; self.<a href="../sui_system/validator_set.md#sui_system_validator_set_any_validator">any_validator</a>(validator_address) } else { // otherwise it's inactive self.inactive_validators[pool_id].load_validator_maybe_upgrade() }; <a href="../sui_system/validator.md#sui_system_validator">validator</a>.get_staking_pool_ref().exchange_rates() } </code></pre> </details>

Function `validator_by_pool_id`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_by_pool_id">validator_by_pool_id</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, pool_id: <a href="../sui/object.md#sui_object_ID">sui::object::ID</a>): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_validator_by_pool_id">validator_by_pool_id</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, pool_id: ID): &Validator { // If the pool id is recorded in the mapping, then it must be either candidate or active. let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = if (self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.contains(pool_id)) { let validator_address = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>[pool_id]; self.<a href="../sui_system/validator_set.md#sui_system_validator_set_any_validator">any_validator</a>(validator_address) } else { // otherwise it's inactive self.inactive_validators[pool_id].load_validator_maybe_upgrade() }; <a href="../sui_system/validator.md#sui_system_validator">validator</a> } </code></pre> </details>

Function `next_epoch_validator_count`

Get the total number of validators in the next epoch.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_next_epoch_validator_count">next_epoch_validator_count</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_next_epoch_validator_count">next_epoch_validator_count</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>): u64 { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.length() - self.pending_removals.length() + self.pending_active_validators.length() } </code></pre> </details>

Function `is_active_validator_by_sui_address`

Returns true iff the address exists in active validators.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_active_validator_by_sui_address">is_active_validator_by_sui_address</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_active_validator_by_sui_address">is_active_validator_by_sui_address</a>( self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address, ): bool { <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, validator_address).is_some() } </code></pre> </details>

Function `is_duplicate_with_active_validator`

Checks whether <code>new_validator</code> is duplicate with any currently active validators. It differs from <code><a href="../sui_system/validator_set.md#sui_system_validator_set_is_active_validator_by_sui_address">is_active_validator_by_sui_address</a></code> in that the former checks only the sui address but this function looks at more metadata.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_active_validator">is_duplicate_with_active_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, new_validator: &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_active_validator">is_duplicate_with_active_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, new_validator: &Validator): bool { <a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_validator">is_duplicate_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, new_validator) } </code></pre> </details>

Function `is_duplicate_validator`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_validator">is_duplicate_validator</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, new_validator: &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_validator">is_duplicate_validator</a>( validators: &vector<Validator>, new_validator: &Validator, ): bool { <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_vec">count_duplicates_vec</a>(validators, new_validator) > 0 } </code></pre> </details>

Function `count_duplicates_vec`

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_vec">count_duplicates_vec</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_vec">count_duplicates_vec</a>(validators: &vector<Validator>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: &Validator): u64 { validators.count!(|v| v.is_duplicate(<a href="../sui_system/validator.md#sui_system_validator">validator</a>)) } </code></pre> </details>

Function `is_duplicate_with_pending_validator`

Checks whether <code>new_validator</code> is duplicate with any currently pending validators.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_pending_validator">is_duplicate_with_pending_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, new_validator: &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_duplicate_with_pending_validator">is_duplicate_with_pending_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, new_validator: &Validator): bool { <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_tablevec">count_duplicates_tablevec</a>(&self.pending_active_validators, new_validator) > 0 } </code></pre> </details>

Function `count_duplicates_tablevec`

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_tablevec">count_duplicates_tablevec</a>(validators: &<a href="../sui/table_vec.md#sui_table_vec_TableVec">sui::table_vec::TableVec</a><<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_count_duplicates_tablevec">count_duplicates_tablevec</a>(validators: &TableVec<Validator>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: &Validator): u64 { let mut result = 0; validators.length().do!(|i| { if (validators[i].is_duplicate(<a href="../sui_system/validator.md#sui_system_validator">validator</a>)) { result = result + 1; }; }); result } </code></pre> </details>

Function `get_candidate_or_active_validator_mut`

Get mutable reference to either a candidate or an active validator by address.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_candidate_or_active_validator_mut">get_candidate_or_active_validator_mut</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address): &mut <a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_candidate_or_active_validator_mut">get_candidate_or_active_validator_mut</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address, ): &mut Validator { if (self.validator_candidates.contains(validator_address)) { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_candidate_validator_mut">candidate_validator_mut</a>(validator_address) } else { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator_mut">active_validator_mut</a>(validator_address) } } </code></pre> </details>

Function `find_validator`

Find validator by <code>validator_address</code>, in <code>validators</code>. Returns (true, index) if the validator is found, and the index is its index in the list. If not found, returns (false, 0).

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, validator_address: address): <a href="../std/option.md#std_option_Option">std::option::Option</a><u64> </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(validators: &vector<Validator>, validator_address: address): Option<u64> { validators.find_index!(|v| v.sui_address() == validator_address) } </code></pre> </details>

Function `find_validator_from_table_vec`

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator_from_table_vec">find_validator_from_table_vec</a>(validators: &<a href="../sui/table_vec.md#sui_table_vec_TableVec">sui::table_vec::TableVec</a><<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, validator_address: address): <a href="../std/option.md#std_option_Option">std::option::Option</a><u64> </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator_from_table_vec">find_validator_from_table_vec</a>( validators: &TableVec<Validator>, validator_address: address, ): Option<u64> { let length = validators.length(); let mut i = 0; while (i < length) { let v = &validators[i]; if (v.sui_address() == validator_address) { return option::some(i) }; i = i + 1; }; option::none() } </code></pre> </details>

Function `get_validator_indices`

Given a vector of validator addresses, return their indices in the validator set. Aborts if any address isn't in the given validator set.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_validator_indices">get_validator_indices</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, validator_addresses: &vector<address>): vector<u64> </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_validator_indices">get_validator_indices</a>( validators: &vector<Validator>, validator_addresses: &vector<address>, ): vector<u64> { let mut res = vector[]; validator_addresses.do_ref!(|addr| { let idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(validators, *addr).destroy_or!(abort <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAValidator">ENotAValidator</a>); res.push_back(idx); }); res } </code></pre> </details>

Function `any_validator`

Get reference to validator in any state: active, pending, or candidate.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_any_validator">any_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_any_validator">any_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &Validator { let active_idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>); if (active_idx.is_some()) { return &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>[active_idx.destroy_some()] }; let pending_idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator_from_table_vec">find_validator_from_table_vec</a>( &self.pending_active_validators, <a href="../sui_system/validator.md#sui_system_validator">validator</a>, ); if (pending_idx.is_some()) { return &self.pending_active_validators[pending_idx.destroy_some()] }; self.validator_candidates[<a href="../sui_system/validator.md#sui_system_validator">validator</a>].load_validator_maybe_upgrade() } </code></pre> </details>

Function `any_validator_mut`

Get mutable reference to validator in any state: active, pending, or candidate.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_any_validator_mut">any_validator_mut</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &mut <a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_any_validator_mut">any_validator_mut</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &mut Validator { let active_idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>); if (active_idx.is_some()) { return &mut self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>[active_idx.destroy_some()] }; let pending_idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator_from_table_vec">find_validator_from_table_vec</a>( &self.pending_active_validators, <a href="../sui_system/validator.md#sui_system_validator">validator</a>, ); if (pending_idx.is_some()) { return &mut self.pending_active_validators[pending_idx.destroy_some()] }; self.validator_candidates[<a href="../sui_system/validator.md#sui_system_validator">validator</a>].load_validator_maybe_upgrade() } </code></pre> </details>

Function `active_validator`

Get reference to an active validator by address.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator">active_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator">active_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &Validator { let idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>).destroy_or!(abort <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAValidator">ENotAValidator</a>); &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>[idx] } </code></pre> </details>

Function `active_validator_mut`

Get mutable reference to an active validator by address.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator_mut">active_validator_mut</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &mut <a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator_mut">active_validator_mut</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address, ): &mut Validator { let idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>).destroy_or!(abort <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAValidator">ENotAValidator</a>); &mut self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>[idx] } </code></pre> </details>

Function `pending_validator`

Get reference to a pending validator by address.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_pending_validator">pending_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_pending_validator">pending_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &Validator { let idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator_from_table_vec">find_validator_from_table_vec</a>(&self.pending_active_validators, <a href="../sui_system/validator.md#sui_system_validator">validator</a>).destroy_or!( abort <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAPendingValidator">ENotAPendingValidator</a>, ); &self.pending_active_validators[idx] } </code></pre> </details>

Function `pending_validator_mut`

Get mutable reference to a pending validator by address.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_pending_validator_mut">pending_validator_mut</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &mut <a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_pending_validator_mut">pending_validator_mut</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address, ): &mut Validator { let idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator_from_table_vec">find_validator_from_table_vec</a>( &self.pending_active_validators, <a href="../sui_system/validator.md#sui_system_validator">validator</a>, ).destroy_or!(abort <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAPendingValidator">ENotAPendingValidator</a>); &mut self.pending_active_validators[idx] } </code></pre> </details>

Function `candidate_validator`

Get mutable reference to a candidate validator by address.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_candidate_validator">candidate_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_candidate_validator">candidate_validator</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &Validator { assert!(self.validator_candidates.contains(<a href="../sui_system/validator.md#sui_system_validator">validator</a>), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotValidatorCandidate">ENotValidatorCandidate</a>); self.validator_candidates[<a href="../sui_system/validator.md#sui_system_validator">validator</a>].load_validator_maybe_upgrade() } </code></pre> </details>

Function `candidate_validator_mut`

Get mutable reference to a candidate validator by address.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_candidate_validator_mut">candidate_validator_mut</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address): &mut <a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_candidate_validator_mut">candidate_validator_mut</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: address, ): &mut Validator { assert!(self.validator_candidates.contains(<a href="../sui_system/validator.md#sui_system_validator">validator</a>), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotValidatorCandidate">ENotValidatorCandidate</a>); self.validator_candidates[<a href="../sui_system/validator.md#sui_system_validator">validator</a>].load_validator_maybe_upgrade() } </code></pre> </details>

Function `get_validator_ref`

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_validator_ref">get_validator_ref</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, validator_address: address): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_validator_ref">get_validator_ref</a>(validators: &vector<Validator>, validator_address: address): &Validator { let idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(validators, validator_address).destroy_or!(abort <a href="../sui_system/validator_set.md#sui_system_validator_set_ENotAValidator">ENotAValidator</a>); &validators[idx] } </code></pre> </details>

Function `get_active_or_pending_or_candidate_validator_ref`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_active_or_pending_or_candidate_validator_ref">get_active_or_pending_or_candidate_validator_ref</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_address: address, which_validator: u8): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_active_or_pending_or_candidate_validator_ref">get_active_or_pending_or_candidate_validator_ref</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_address: address, which_validator: u8, ): &Validator { let mut validator_index_opt = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, validator_address); if (validator_index_opt.is_some() || which_validator == <a href="../sui_system/validator_set.md#sui_system_validator_set_ACTIVE_VALIDATOR_ONLY">ACTIVE_VALIDATOR_ONLY</a>) { let validator_index = validator_index_opt.extract(); return &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>[validator_index] }; let mut validator_index_opt = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator_from_table_vec">find_validator_from_table_vec</a>( &self.pending_active_validators, validator_address, ); if (validator_index_opt.is_some() || which_validator == <a href="../sui_system/validator_set.md#sui_system_validator_set_ACTIVE_OR_PENDING_VALIDATOR">ACTIVE_OR_PENDING_VALIDATOR</a>) { let validator_index = validator_index_opt.extract(); return &self.pending_active_validators[validator_index] }; self.validator_candidates[validator_address].load_validator_maybe_upgrade() } </code></pre> </details>

Function `verify_cap`

Verify the capability is valid for a Validator. If <code>active_validator_only</code> is true, only verify the Cap for an active validator. Otherwise, verify the Cap for au either active or pending validator.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_verify_cap">verify_cap</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, cap: &<a href="../sui_system/validator_cap.md#sui_system_validator_cap_UnverifiedValidatorOperationCap">sui_system::validator_cap::UnverifiedValidatorOperationCap</a>, which_validator: u8): <a href="../sui_system/validator_cap.md#sui_system_validator_cap_ValidatorOperationCap">sui_system::validator_cap::ValidatorOperationCap</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_verify_cap">verify_cap</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, cap: &UnverifiedValidatorOperationCap, which_validator: u8, ): ValidatorOperationCap { let cap_address = *cap.unverified_operation_cap_address(); let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = match (which_validator) { <a href="../sui_system/validator_set.md#sui_system_validator_set_ACTIVE_VALIDATOR_ONLY">ACTIVE_VALIDATOR_ONLY</a> => self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator">active_validator</a>(cap_address), <a href="../sui_system/validator_set.md#sui_system_validator_set_ACTIVE_OR_PENDING_VALIDATOR">ACTIVE_OR_PENDING_VALIDATOR</a> => { let active_idx = <a href="../sui_system/validator_set.md#sui_system_validator_set_find_validator">find_validator</a>(&self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, cap_address); if (active_idx.is_some()) { &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>[active_idx.destroy_some()] } else { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_pending_validator">pending_validator</a>(cap_address) } }, <a href="../sui_system/validator_set.md#sui_system_validator_set_ANY_VALIDATOR">ANY_VALIDATOR</a> => self.<a href="../sui_system/validator_set.md#sui_system_validator_set_any_validator">any_validator</a>(cap_address), _ => abort <a href="../sui_system/validator_set.md#sui_system_validator_set_EInvalidValidatorSelector">EInvalidValidatorSelector</a>, }; assert!(<a href="../sui_system/validator.md#sui_system_validator">validator</a>.operation_cap_id() == &object::id(cap), <a href="../sui_system/validator_set.md#sui_system_validator_set_EInvalidCap">EInvalidCap</a>); cap.into_verified() } </code></pre> </details>

Function `process_pending_removals`

Process the pending withdraw requests. For each pending request, the validator is removed from <code>validators</code> and its staking pool is put into the <code>inactive_validators</code> table.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_process_pending_removals">process_pending_removals</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_report_records: &mut <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, <a href="../sui/vec_set.md#sui_vec_set_VecSet">sui::vec_set::VecSet</a><address>>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_process_pending_removals">process_pending_removals</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, validator_report_records: &mut VecMap<address, VecSet<address>>, ctx: &mut TxContext, ) { <a href="../sui_system/validator_set.md#sui_system_validator_set_sort_removal_list">sort_removal_list</a>(&mut self.pending_removals); self.pending_removals.length().do!(|_| { let index = self.pending_removals.pop_back(); let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.remove(index); self.<a href="../sui_system/validator_set.md#sui_system_validator_set_process_validator_departure">process_validator_departure</a>( <a href="../sui_system/validator.md#sui_system_validator">validator</a>, validator_report_records, true, // the <a href="../sui_system/validator.md#sui_system_validator">validator</a> removes itself voluntarily ctx, ); }); } </code></pre> </details>

Function `process_validator_departure`

Remove <code><a href="../sui_system/validator.md#sui_system_validator">validator</a></code> from <code>self</code> and return the amount of stake that was removed

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_process_validator_departure">process_validator_departure</a>(self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, <a href="../sui_system/validator.md#sui_system_validator">validator</a>: <a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>, validator_report_records: &mut <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, <a href="../sui/vec_set.md#sui_vec_set_VecSet">sui::vec_set::VecSet</a><address>>, is_voluntary: bool, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_process_validator_departure">process_validator_departure</a>( self: &mut <a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, mut <a href="../sui_system/validator.md#sui_system_validator">validator</a>: Validator, validator_report_records: &mut VecMap<address, VecSet<address>>, is_voluntary: bool, ctx: &mut TxContext, ): u64 { let new_epoch = ctx.epoch() + 1; let validator_address = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.sui_address(); let validator_pool_id = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.staking_pool_id(); // Remove the <a href="../sui_system/validator.md#sui_system_validator">validator</a> from our tables. self.<a href="../sui_system/validator_set.md#sui_system_validator_set_staking_pool_mappings">staking_pool_mappings</a>.remove(validator_pool_id); if (self.at_risk_validators.contains(&validator_address)) { self.at_risk_validators.remove(&validator_address); }; <a href="../sui_system/validator_set.md#sui_system_validator_set_clean_report_records_leaving_validator">clean_report_records_leaving_validator</a>(validator_report_records, validator_address); event::emit(<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorLeaveEvent">ValidatorLeaveEvent</a> { epoch: new_epoch, validator_address, staking_pool_id: <a href="../sui_system/validator.md#sui_system_validator">validator</a>.staking_pool_id(), is_voluntary, }); // Deactivate the <a href="../sui_system/validator.md#sui_system_validator">validator</a> and its staking pool let removed_stake = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>(); <a href="../sui_system/validator.md#sui_system_validator">validator</a>.deactivate(new_epoch); self .inactive_validators .add( validator_pool_id, <a href="../sui_system/validator.md#sui_system_validator">validator</a>.wrap_v1(ctx), ); removed_stake } </code></pre> </details>

Function `clean_report_records_leaving_validator`

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_clean_report_records_leaving_validator">clean_report_records_leaving_validator</a>(validator_report_records: &mut <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, <a href="../sui/vec_set.md#sui_vec_set_VecSet">sui::vec_set::VecSet</a><address>>, leaving_validator_addr: address) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_clean_report_records_leaving_validator">clean_report_records_leaving_validator</a>( validator_report_records: &mut VecMap<address, VecSet<address>>, leaving_validator_addr: address, ) { // Remove the records about this <a href="../sui_system/validator.md#sui_system_validator">validator</a> if (validator_report_records.contains(&leaving_validator_addr)) { validator_report_records.remove(&leaving_validator_addr); }; // Remove the reports submitted by this <a href="../sui_system/validator.md#sui_system_validator">validator</a> let reported_validators = validator_report_records.keys(); reported_validators.length().do!(|i| { let reported_validator_addr = &reported_validators[i]; let reporters = &mut validator_report_records[reported_validator_addr]; if (reporters.contains(&leaving_validator_addr)) { reporters.remove(&leaving_validator_addr); if (reporters.is_empty()) { validator_report_records.remove(reported_validator_addr); }; }; }); } </code></pre> </details>

Function `sort_removal_list`

Sort all the pending removal indexes.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_sort_removal_list">sort_removal_list</a>(withdraw_list: &mut vector<u64>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_sort_removal_list">sort_removal_list</a>(withdraw_list: &mut vector<u64>) { let length = withdraw_list.length(); let mut i = 1; while (i < length) { let cur = withdraw_list[i]; let mut j = i; while (j > 0) { j = j - 1; if (withdraw_list[j] > cur) { withdraw_list.swap(j, j + 1); } else { break }; }; i = i + 1; }; } </code></pre> </details>

Function `process_pending_stakes_and_withdraws`

Process all active validators' pending stake deposits and withdraws.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_process_pending_stakes_and_withdraws">process_pending_stakes_and_withdraws</a>(validators: &mut vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, ctx: &<a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_process_pending_stakes_and_withdraws">process_pending_stakes_and_withdraws</a>(validators: &mut vector<Validator>, ctx: &TxContext) { validators.do_mut!(|v| v.<a href="../sui_system/validator_set.md#sui_system_validator_set_process_pending_stakes_and_withdraws">process_pending_stakes_and_withdraws</a>(ctx)) } </code></pre> </details>

Function `calculate_total_stakes`

Calculate the total active validator stake.

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_calculate_total_stakes">calculate_total_stakes</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_calculate_total_stakes">calculate_total_stakes</a>(validators: &vector<Validator>): u64 { let mut stake = 0; validators.do_ref!(|v| stake = stake + v.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>()); stake } </code></pre> </details>

Function `adjust_stake_and_gas_price`

Process the pending stake changes for each validator.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_adjust_stake_and_gas_price">adjust_stake_and_gas_price</a>(validators: &mut vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_adjust_stake_and_gas_price">adjust_stake_and_gas_price</a>(validators: &mut vector<Validator>) { validators.do_mut!(|v| v.<a href="../sui_system/validator_set.md#sui_system_validator_set_adjust_stake_and_gas_price">adjust_stake_and_gas_price</a>()) } </code></pre> </details>

Function `compute_reward_adjustments`

Compute both the individual reward adjustments and total reward adjustment for staking rewards as well as storage fund rewards.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_reward_adjustments">compute_reward_adjustments</a>(slashed_validator_indices: vector<u64>, reward_slashing_rate: u64, unadjusted_staking_reward_amounts: &vector<u64>, unadjusted_storage_fund_reward_amounts: &vector<u64>): (u64, <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><u64, u64>, u64, <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><u64, u64>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_reward_adjustments">compute_reward_adjustments</a>( slashed_validator_indices: vector<u64>, reward_slashing_rate: u64, unadjusted_staking_reward_amounts: &vector<u64>, unadjusted_storage_fund_reward_amounts: &vector<u64>, ): ( u64, // sum of staking reward adjustments VecMap<u64, u64>, // mapping of individual <a href="../sui_system/validator.md#sui_system_validator">validator</a>'s staking reward adjustment from index -> amount u64, // sum of storage fund reward adjustments VecMap<u64, u64>, // mapping of individual <a href="../sui_system/validator.md#sui_system_validator">validator</a>'s storage fund reward adjustment from index -> amount ) { let mut total_staking_reward_adjustment = 0; let mut individual_staking_reward_adjustments = vec_map::empty(); let mut total_storage_fund_reward_adjustment = 0; let mut individual_storage_fund_reward_adjustments = vec_map::empty(); slashed_validator_indices.destroy!(|validator_index| { // Use the slashing rate to compute the amount of staking rewards slashed from this punished <a href="../sui_system/validator.md#sui_system_validator">validator</a>. let unadjusted_staking_reward = unadjusted_staking_reward_amounts[validator_index]; let staking_reward_adjustment = <a href="../sui_system/validator_set.md#sui_system_validator_set_mul_div">mul_div</a>!( unadjusted_staking_reward, reward_slashing_rate, <a href="../sui_system/validator_set.md#sui_system_validator_set_BASIS_POINT_DENOMINATOR">BASIS_POINT_DENOMINATOR</a>, ); // Insert into individual mapping and record into the total adjustment sum. individual_staking_reward_adjustments.insert(validator_index, staking_reward_adjustment); total_staking_reward_adjustment = total_staking_reward_adjustment + staking_reward_adjustment; // Do the same thing for storage fund rewards. let unadjusted_storage_fund_reward = unadjusted_storage_fund_reward_amounts[ validator_index, ]; let storage_fund_reward_adjustment = <a href="../sui_system/validator_set.md#sui_system_validator_set_mul_div">mul_div</a>!( unadjusted_storage_fund_reward, reward_slashing_rate, <a href="../sui_system/validator_set.md#sui_system_validator_set_BASIS_POINT_DENOMINATOR">BASIS_POINT_DENOMINATOR</a>, ); individual_storage_fund_reward_adjustments.insert( validator_index, storage_fund_reward_adjustment, ); total_storage_fund_reward_adjustment = total_storage_fund_reward_adjustment + storage_fund_reward_adjustment; }); ( total_staking_reward_adjustment, individual_staking_reward_adjustments, total_storage_fund_reward_adjustment, individual_storage_fund_reward_adjustments, ) } </code></pre> </details>

Function `compute_slashed_validators`

Process the validator report records of the epoch and return the addresses of the non-performant validators according to the input threshold.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_slashed_validators">compute_slashed_validators</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, validator_report_records: <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, <a href="../sui/vec_set.md#sui_vec_set_VecSet">sui::vec_set::VecSet</a><address>>): vector<address> </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_slashed_validators">compute_slashed_validators</a>( self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, mut validator_report_records: VecMap<address, VecSet<address>>, ): vector<address> { let mut slashed_validators = vector[]; while (!validator_report_records.is_empty()) { let (validator_address, reporters) = validator_report_records.pop(); assert!( self.<a href="../sui_system/validator_set.md#sui_system_validator_set_is_active_validator_by_sui_address">is_active_validator_by_sui_address</a>(validator_address), <a href="../sui_system/validator_set.md#sui_system_validator_set_ENonValidatorInReportRecords">ENonValidatorInReportRecords</a>, ); // Sum up the voting power of validators that have reported this <a href="../sui_system/validator.md#sui_system_validator">validator</a> and check if it has // passed the slashing threshold. let reporter_votes = <a href="../sui_system/validator_set.md#sui_system_validator_set_sum_voting_power_by_addresses">sum_voting_power_by_addresses</a>( &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>, &reporters.into_keys(), ); if (reporter_votes >= <a href="../sui_system/voting_power.md#sui_system_voting_power_quorum_threshold">voting_power::quorum_threshold</a>()) { slashed_validators.push_back(validator_address); } }; slashed_validators } </code></pre> </details>

Function `compute_unadjusted_reward_distribution`

Given the current list of active validators, the total stake and total reward, calculate the amount of reward each validator should get, without taking into account the tallying rule results. Returns the unadjusted amounts of staking reward and storage fund reward for each validator.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_unadjusted_reward_distribution">compute_unadjusted_reward_distribution</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, total_voting_power: u64, total_staking_reward: u64, total_storage_fund_reward: u64): (vector<u64>, vector<u64>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_unadjusted_reward_distribution">compute_unadjusted_reward_distribution</a>( validators: &vector<Validator>, total_voting_power: u64, total_staking_reward: u64, total_storage_fund_reward: u64, ): (vector<u64>, vector<u64>) { let mut staking_reward_amounts = vector[]; let mut storage_fund_reward_amounts = vector[]; let length = validators.length(); let storage_fund_reward_per_validator = total_storage_fund_reward / length; validators.do_ref!(|<a href="../sui_system/validator.md#sui_system_validator">validator</a>| { // Integer divisions will truncate the results. Because of this, we expect that at the end // there will be some reward remaining in `total_staking_reward`. // Use u128 to avoid multiplication overflow. let <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a> = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>(); let reward_amount = <a href="../sui_system/validator_set.md#sui_system_validator_set_mul_div">mul_div</a>!(<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>, total_staking_reward, total_voting_power); staking_reward_amounts.push_back(reward_amount); // Storage fund's share of the rewards are equally distributed among validators. storage_fund_reward_amounts.push_back(storage_fund_reward_per_validator); }); (staking_reward_amounts, storage_fund_reward_amounts) } </code></pre> </details>

Function `compute_adjusted_reward_distribution`

Use the reward adjustment info to compute the adjusted rewards each validator should get. Returns the staking rewards each validator gets and the storage fund rewards each validator gets. The staking rewards are shared with the stakers while the storage fund ones are not.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_adjusted_reward_distribution">compute_adjusted_reward_distribution</a>(validators: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, total_voting_power: u64, total_slashed_validator_voting_power: u64, unadjusted_staking_reward_amounts: vector<u64>, unadjusted_storage_fund_reward_amounts: vector<u64>, total_staking_reward_adjustment: u64, individual_staking_reward_adjustments: <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><u64, u64>, total_storage_fund_reward_adjustment: u64, individual_storage_fund_reward_adjustments: <a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><u64, u64>): (vector<u64>, vector<u64>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_compute_adjusted_reward_distribution">compute_adjusted_reward_distribution</a>( validators: &vector<Validator>, total_voting_power: u64, total_slashed_validator_voting_power: u64, unadjusted_staking_reward_amounts: vector<u64>, unadjusted_storage_fund_reward_amounts: vector<u64>, total_staking_reward_adjustment: u64, individual_staking_reward_adjustments: VecMap<u64, u64>, total_storage_fund_reward_adjustment: u64, individual_storage_fund_reward_adjustments: VecMap<u64, u64>, ): (vector<u64>, vector<u64>) { let total_unslashed_validator_voting_power = total_voting_power - total_slashed_validator_voting_power; let mut adjusted_staking_reward_amounts = vector[]; let mut adjusted_storage_fund_reward_amounts = vector[]; let length = validators.length(); let num_unslashed_validators = length - individual_staking_reward_adjustments.length(); length.do!(|i| { let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = &validators[i]; // Integer divisions will truncate the results. Because of this, we expect that at the end // there will be some reward remaining in `total_reward`. // Use u128 to avoid multiplication overflow. let <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a> = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>(); // Compute adjusted staking reward. let unadjusted_staking_reward_amount = unadjusted_staking_reward_amounts[i]; // If the <a href="../sui_system/validator.md#sui_system_validator">validator</a> is one of the slashed ones, then subtract the adjustment. let adjusted_staking_reward_amount = if ( individual_staking_reward_adjustments.contains(&i) ) { let adjustment = individual_staking_reward_adjustments[&i]; unadjusted_staking_reward_amount - adjustment } else { // Otherwise the slashed rewards should be distributed among the unslashed // validators so add the corresponding adjustment. let adjustment = <a href="../sui_system/validator_set.md#sui_system_validator_set_mul_div">mul_div</a>!( total_staking_reward_adjustment, <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>, total_unslashed_validator_voting_power, ); unadjusted_staking_reward_amount + adjustment }; adjusted_staking_reward_amounts.push_back(adjusted_staking_reward_amount); // Compute adjusted storage fund reward. let unadjusted_storage_fund_reward_amount = unadjusted_storage_fund_reward_amounts[i]; // If the <a href="../sui_system/validator.md#sui_system_validator">validator</a> is one of the slashed ones, then subtract the adjustment. let adjusted_storage_fund_reward_amount = if ( individual_storage_fund_reward_adjustments.contains(&i) ) { let adjustment = individual_storage_fund_reward_adjustments[&i]; unadjusted_storage_fund_reward_amount - adjustment } else { // Otherwise the slashed rewards should be equally distributed among the unslashed validators. let adjustment = total_storage_fund_reward_adjustment / num_unslashed_validators; unadjusted_storage_fund_reward_amount + adjustment }; adjusted_storage_fund_reward_amounts.push_back(adjusted_storage_fund_reward_amount); }); (adjusted_staking_reward_amounts, adjusted_storage_fund_reward_amounts) } </code></pre> </details>

Function `distribute_reward`

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_distribute_reward">distribute_reward</a>(validators: &mut vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, adjusted_staking_reward_amounts: &vector<u64>, adjusted_storage_fund_reward_amounts: &vector<u64>, staking_rewards: &mut <a href="../sui/balance.md#sui_balance_Balance">sui::balance::Balance</a><<a href="../sui/sui.md#sui_sui_SUI">sui::sui::SUI</a>>, storage_fund_reward: &mut <a href="../sui/balance.md#sui_balance_Balance">sui::balance::Balance</a><<a href="../sui/sui.md#sui_sui_SUI">sui::sui::SUI</a>>, ctx: &mut <a href="../sui/tx_context.md#sui_tx_context_TxContext">sui::tx_context::TxContext</a>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_distribute_reward">distribute_reward</a>( validators: &mut vector<Validator>, adjusted_staking_reward_amounts: &vector<u64>, adjusted_storage_fund_reward_amounts: &vector<u64>, staking_rewards: &mut Balance<SUI>, storage_fund_reward: &mut Balance<SUI>, ctx: &mut TxContext, ) { let length = validators.length(); assert!(length > 0, <a href="../sui_system/validator_set.md#sui_system_validator_set_EValidatorSetEmpty">EValidatorSetEmpty</a>); length.do!(|i| { let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = &mut validators[i]; let staking_reward_amount = adjusted_staking_reward_amounts[i]; let mut staker_reward = staking_rewards.split(staking_reward_amount); // Validator takes a cut of the rewards as commission. let validator_commission_amount = <a href="../sui_system/validator_set.md#sui_system_validator_set_mul_div">mul_div</a>!( staking_reward_amount, <a href="../sui_system/validator.md#sui_system_validator">validator</a>.commission_rate(), <a href="../sui_system/validator_set.md#sui_system_validator_set_BASIS_POINT_DENOMINATOR">BASIS_POINT_DENOMINATOR</a>, ); // The <a href="../sui_system/validator.md#sui_system_validator">validator</a> reward = storage_fund_reward + commission. let mut validator_reward = staker_reward.split(validator_commission_amount as u64); // Add storage fund rewards to the <a href="../sui_system/validator.md#sui_system_validator">validator</a>'s reward. validator_reward.join(storage_fund_reward.split(adjusted_storage_fund_reward_amounts[i])); // Add rewards to the <a href="../sui_system/validator.md#sui_system_validator">validator</a>. Don't try and distribute rewards though if the payout is zero. if (validator_reward.value() > 0) { let validator_address = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.sui_address(); let rewards_stake = <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/validator_set.md#sui_system_validator_set_request_add_stake">request_add_stake</a>( validator_reward, validator_address, ctx, ); transfer::public_transfer(rewards_stake, validator_address); } else { validator_reward.destroy_zero(); }; // Add rewards to stake staking pool to auto compound for stakers. <a href="../sui_system/validator.md#sui_system_validator">validator</a>.deposit_stake_rewards(staker_reward); }); } </code></pre> </details>

Function `emit_validator_epoch_events`

Emit events containing information of each validator for the epoch, including stakes, rewards, performance, etc.

<pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_emit_validator_epoch_events">emit_validator_epoch_events</a>(new_epoch: u64, vs: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, pool_staking_reward_amounts: &vector<u64>, storage_fund_staking_reward_amounts: &vector<u64>, report_records: &<a href="../sui/vec_map.md#sui_vec_map_VecMap">sui::vec_map::VecMap</a><address, <a href="../sui/vec_set.md#sui_vec_set_VecSet">sui::vec_set::VecSet</a><address>>, slashed_validators: &vector<address>) </code></pre> <details> <summary>Implementation</summary> <pre><code>fun <a href="../sui_system/validator_set.md#sui_system_validator_set_emit_validator_epoch_events">emit_validator_epoch_events</a>( new_epoch: u64, vs: &vector<Validator>, pool_staking_reward_amounts: &vector<u64>, storage_fund_staking_reward_amounts: &vector<u64>, report_records: &VecMap<address, VecSet<address>>, slashed_validators: &vector<address>, ) { let length = vs.length(); length.do!(|i| { let v = &vs[i]; let validator_address = v.sui_address(); let tallying_rule_reporters = if (report_records.contains(&validator_address)) { report_records[&validator_address].into_keys() } else { vector[] }; let tallying_rule_global_score = if (slashed_validators.contains(&validator_address)) { 0 } else { 1 }; event::emit(<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorEpochInfoEventV2">ValidatorEpochInfoEventV2</a> { epoch: new_epoch, validator_address, reference_gas_survey_quote: v.gas_price(), stake: v.<a href="../sui_system/validator_set.md#sui_system_validator_set_total_stake">total_stake</a>(), <a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>: v.<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>(), commission_rate: v.commission_rate(), pool_staking_reward: pool_staking_reward_amounts[i], storage_fund_staking_reward: storage_fund_staking_reward_amounts[i], pool_token_exchange_rate: v.pool_token_exchange_rate_at_epoch(new_epoch), tallying_rule_reporters, tallying_rule_global_score, }); }); } </code></pre> </details>

Function `sum_voting_power_by_addresses`

Sum up the total stake of a given list of validator addresses.

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_sum_voting_power_by_addresses">sum_voting_power_by_addresses</a>(vs: &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>>, addresses: &vector<address>): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_sum_voting_power_by_addresses">sum_voting_power_by_addresses</a>(vs: &vector<Validator>, addresses: &vector<address>): u64 { let mut sum = 0; addresses.do_ref!(|addr| { let <a href="../sui_system/validator.md#sui_system_validator">validator</a> = <a href="../sui_system/validator_set.md#sui_system_validator_set_get_validator_ref">get_validator_ref</a>(vs, *addr); sum = sum + <a href="../sui_system/validator.md#sui_system_validator">validator</a>.<a href="../sui_system/voting_power.md#sui_system_voting_power">voting_power</a>(); }); sum } </code></pre> </details>

Function `active_validators`

Return the active validators in <code>self</code>

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>): &vector<<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a>> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>): &vector<Validator> { &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a> } </code></pre> </details>

Function `is_validator_candidate`

Returns true if the <code>addr</code> is a validator candidate.

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_validator_candidate">is_validator_candidate</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, addr: address): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_validator_candidate">is_validator_candidate</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, addr: address): bool { self.validator_candidates.contains(addr) } </code></pre> </details>

Function `is_active_validator`

Returns true if <code>addr</code> is an active validator

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_active_validator">is_active_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, addr: address): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_active_validator">is_active_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, addr: address): bool { self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>.any!(|v| v.sui_address() == addr) } </code></pre> </details>

Function `is_inactive_validator`

Returns true if the staking pool identified by <code>staking_pool_id</code> is of an inactive validator.

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_inactive_validator">is_inactive_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, staking_pool_id: <a href="../sui/object.md#sui_object_ID">sui::object::ID</a>): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_inactive_validator">is_inactive_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, staking_pool_id: ID): bool { self.inactive_validators.contains(staking_pool_id) } </code></pre> </details>

Function `is_at_risk_validator`

Return true if <code>addr</code> is currently an at-risk validator below the minimum stake for removal

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_at_risk_validator">is_at_risk_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, addr: address): bool </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_is_at_risk_validator">is_at_risk_validator</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, addr: address): bool { self.at_risk_validators.contains(&addr) } </code></pre> </details>

Function `active_validator_addresses`

<pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator_addresses">active_validator_addresses</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>): vector<address> </code></pre> <details> <summary>Implementation</summary> <pre><code>public(package) fun <a href="../sui_system/validator_set.md#sui_system_validator_set_active_validator_addresses">active_validator_addresses</a>(self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>): vector<address> { let vs = &self.<a href="../sui_system/validator_set.md#sui_system_validator_set_active_validators">active_validators</a>; let mut res = vector[]; vs.do_ref!(|v| res.push_back(v.sui_address())); res } </code></pre> </details>

Macro function `mul_div`

<pre><code>macro fun <a href="../sui_system/validator_set.md#sui_system_validator_set_mul_div">mul_div</a>($a: u64, $b: u64, $c: u64): u64 </code></pre> <details> <summary>Implementation</summary> <pre><code>macro fun <a href="../sui_system/validator_set.md#sui_system_validator_set_mul_div">mul_div</a>($a: u64, $b: u64, $c: u64): u64 { (($a as u128) * ($b as u128) / ($c as u128)) as u64 } </code></pre> </details>

Function `get_active_validator_ref`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_active_validator_ref">get_active_validator_ref</a>(_self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, _addr: address): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_active_validator_ref">get_active_validator_ref</a>(_self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, _addr: address): &Validator { abort } </code></pre> </details>

Function `get_pending_validator_ref`

<pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_pending_validator_ref">get_pending_validator_ref</a>(_self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">sui_system::validator_set::ValidatorSet</a>, _addr: address): &<a href="../sui_system/validator.md#sui_system_validator_Validator">sui_system::validator::Validator</a> </code></pre> <details> <summary>Implementation</summary> <pre><code>public fun <a href="../sui_system/validator_set.md#sui_system_validator_set_get_pending_validator_ref">get_pending_validator_ref</a>(_self: &<a href="../sui_system/validator_set.md#sui_system_validator_set_ValidatorSet">ValidatorSet</a>, _addr: address): &Validator { abort } </code></pre> </details>

Struct ValidatorSet

Struct ValidatorEpochInfoEvent

Struct ValidatorEpochInfoEventV2

Struct ValidatorJoinEvent

Struct ValidatorLeaveEvent

Struct VotingPowerAdmissionStartEpochKey

Constants

Function new

Function request_add_validator_candidate

Function request_remove_validator_candidate

Function request_add_validator

Function can_join

Function get_voting_power_thresholds

Function assert_no_pending_or_active_duplicates

Function request_remove_validator

Function request_add_stake

Function request_withdraw_stake

Function convert_to_fungible_staked_sui

Function redeem_fungible_staked_sui

Function advance_epoch

Function update_validator_positions_and_calculate_total_stake

Function effectuate_staged_metadata

Function derive_reference_gas_price

Function total_stake

Function validator_total_stake_amount

Function validator_stake_amount

Function validator_voting_power

Function validator_staking_pool_id

Function staking_pool_mappings

Function validator_address_by_pool_id

Function pool_exchange_rates

Function validator_by_pool_id

Function next_epoch_validator_count

Function is_active_validator_by_sui_address

Function is_duplicate_with_active_validator

Function is_duplicate_validator

Function count_duplicates_vec

Function is_duplicate_with_pending_validator

Function count_duplicates_tablevec

Function get_candidate_or_active_validator_mut

Function find_validator

Function find_validator_from_table_vec

Function get_validator_indices

Function any_validator

Function any_validator_mut

Function active_validator

Function active_validator_mut

Function pending_validator

Function pending_validator_mut

Function candidate_validator

Function candidate_validator_mut

Function get_validator_ref

Function get_active_or_pending_or_candidate_validator_ref

Function verify_cap

Function process_pending_removals

Function process_validator_departure

Function clean_report_records_leaving_validator

Function sort_removal_list

Function process_pending_stakes_and_withdraws

Function calculate_total_stakes

Function adjust_stake_and_gas_price

Function compute_reward_adjustments

Function compute_slashed_validators

Function compute_unadjusted_reward_distribution

Function compute_adjusted_reward_distribution

Function distribute_reward

Function emit_validator_epoch_events

Function sum_voting_power_by_addresses

Function active_validators

Function is_validator_candidate

Function is_active_validator

Function is_inactive_validator

Function is_at_risk_validator

Function active_validator_addresses

Macro function mul_div

Function get_active_validator_ref

Function get_pending_validator_ref