validator_set
Module0x0000…0003
- Move path
- 0x0000…0003::validator_set
- Functions
- 6214 public, 0 entry
- Structs
- 6
- Friend modules
- sui_systemsui_system_state_inner
validator_set
Bytecode3674 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module 3.validator_set {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::priority_queue;
use 0000000000000000000000000000000000000000000000000000000000000002::sui;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::table_vec;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000003::staking_pool;
use 0000000000000000000000000000000000000000000000000000000000000003::validator;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_cap;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_wrapper;
use 0000000000000000000000000000000000000000000000000000000000000003::voting_power;
struct ValidatorSet has store {
total_stake: u64,
active_validators: vector<Validator>,
pending_active_validators: TableVec<Validator>,
pending_removals: vector<u64>,
staking_pool_mappings: Table<ID, address>,
inactive_validators: Table<ID, ValidatorWrapper>,
validator_candidates: Table<address, ValidatorWrapper>,
at_risk_validators: VecMap<address, u64>,
extra_fields: Bag
}
struct ValidatorEpochInfoEvent has copy, drop {
epoch: u64,
validator_address: address,
reference_gas_survey_quote: u64,
stake: u64,
commission_rate: u64,
pool_staking_reward: u64,
storage_fund_staking_reward: u64,
pool_token_exchange_rate: PoolTokenExchangeRate,
tallying_rule_reporters: vector<address>,
tallying_rule_global_score: u64
}
struct ValidatorEpochInfoEventV2 has copy, drop {
epoch: u64,
validator_address: address,
reference_gas_survey_quote: u64,
stake: u64,
voting_power: u64,
commission_rate: u64,
pool_staking_reward: u64,
storage_fund_staking_reward: u64,
pool_token_exchange_rate: PoolTokenExchangeRate,
tallying_rule_reporters: vector<address>,
tallying_rule_global_score: u64
}
struct ValidatorJoinEvent has copy, drop {
epoch: u64,
validator_address: address,
staking_pool_id: ID
}
struct ValidatorLeaveEvent has copy, drop {
epoch: u64,
validator_address: address,
staking_pool_id: ID,
is_voluntary: bool
}
struct VotingPowerAdmissionStartEpochKey has copy, drop, store {
dummy_field: bool
}
public(friend) new(Arg0: vector<Validator>, Arg1: &mut TxContext): ValidatorSet {
L2: loc0: u64
L3: loc1: u64
L4: loc2: u64
L5: loc3: Table<ID, address>
L6: loc4: u64
L7: loc5: u64
L8: loc6: &vector<Validator>
L9: loc7: &Validator
L10: loc8: ValidatorSet
B0:
0ImmBorrowLoc[0](Arg0: vector<Validator>)
1Call calculate_total_stakes(&vector<Validator>): u64
2StLoc[7](loc5: u64)
3CopyLoc[1](Arg1: &mut TxContext)
4Call table::new<ID, address>(&mut TxContext): Table<ID, address>
5StLoc[5](loc3: Table<ID, address>)
6ImmBorrowLoc[0](Arg0: vector<Validator>)
7StLoc[8](loc6: &vector<Validator>)
8CopyLoc[8](loc6: &vector<Validator>)
9VecLen(58)
10StLoc[2](loc0: u64)
11LdU64(0)
12StLoc[3](loc1: u64)
13MoveLoc[2](loc0: u64)
14StLoc[6](loc4: u64)
B1:
15CopyLoc[3](loc1: u64)
16CopyLoc[6](loc4: u64)
17Lt
18BrFalse(36)
B2:
19CopyLoc[3](loc1: u64)
20StLoc[4](loc2: u64)
21CopyLoc[8](loc6: &vector<Validator>)
22MoveLoc[4](loc2: u64)
23VecImmBorrow(58)
24StLoc[9](loc7: &Validator)
25MutBorrowLoc[5](loc3: Table<ID, address>)
26CopyLoc[9](loc7: &Validator)
27Call validator::staking_pool_id(&Validator): ID
28MoveLoc[9](loc7: &Validator)
29Call validator::sui_address(&Validator): address
30Call table::add<ID, address>(&mut Table<ID, address>, ID, address)
31MoveLoc[3](loc1: u64)
32LdU64(1)
33Add
34StLoc[3](loc1: u64)
35Branch(15)
B3:
36MoveLoc[8](loc6: &vector<Validator>)
37Pop
38CopyLoc[7](loc5: u64)
39MoveLoc[0](Arg0: vector<Validator>)
40CopyLoc[1](Arg1: &mut TxContext)
41Call table_vec::empty<Validator>(&mut TxContext): TableVec<Validator>
42LdConst[21](vector<u64>: 00)
43MoveLoc[5](loc3: Table<ID, address>)
44CopyLoc[1](Arg1: &mut TxContext)
45Call table::new<ID, ValidatorWrapper>(&mut TxContext): Table<ID, ValidatorWrapper>
46CopyLoc[1](Arg1: &mut TxContext)
47Call table::new<address, ValidatorWrapper>(&mut TxContext): Table<address, ValidatorWrapper>
48Call vec_map::empty<address, u64>(): VecMap<address, u64>
49MoveLoc[1](Arg1: &mut TxContext)
50Call bag::new(&mut TxContext): Bag
51Pack[0](ValidatorSet)
52StLoc[10](loc8: ValidatorSet)
53MutBorrowLoc[10](loc8: ValidatorSet)
54MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
55MoveLoc[7](loc5: u64)
56Call voting_power::set_voting_power(&mut vector<Validator>, u64)
57MoveLoc[10](loc8: ValidatorSet)
58Ret
}
public(friend) request_add_validator_candidate(Arg0: &mut ValidatorSet, Arg1: Validator, Arg2: &mut TxContext) {
L3: loc0: Option<u64>
L4: loc1: Option<u64>
L5: loc2: address
B0:
0ImmBorrowLoc[1](Arg1: Validator)
1Call validator::sui_address(&Validator): address
2StLoc[5](loc2: address)
3CopyLoc[0](Arg0: &mut ValidatorSet)
4ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
5CopyLoc[5](loc2: address)
6Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
7Not
8BrFalse(10)
B1:
9Branch(16)
B2:
10MoveLoc[0](Arg0: &mut ValidatorSet)
11Pop
12MoveLoc[2](Arg2: &mut TxContext)
13Pop
14LdConst[6](u64: 6)
15Abort
B3:
16CopyLoc[0](Arg0: &mut ValidatorSet)
17ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
18CopyLoc[5](loc2: address)
19Call find_validator(&vector<Validator>, address): Option<u64>
20StLoc[3](loc0: Option<u64>)
21ImmBorrowLoc[3](loc0: Option<u64>)
22Call option::is_none<u64>(&Option<u64>): bool
23BrFalse(25)
B4:
24Branch(31)
B5:
25MoveLoc[0](Arg0: &mut ValidatorSet)
26Pop
27MoveLoc[2](Arg2: &mut TxContext)
28Pop
29LdConst[15](u64: 15)
30Abort
B6:
31CopyLoc[0](Arg0: &mut ValidatorSet)
32ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
33CopyLoc[5](loc2: address)
34Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
35StLoc[4](loc1: Option<u64>)
36ImmBorrowLoc[4](loc1: Option<u64>)
37Call option::is_none<u64>(&Option<u64>): bool
38BrFalse(40)
B7:
39Branch(46)
B8:
40MoveLoc[0](Arg0: &mut ValidatorSet)
41Pop
42MoveLoc[2](Arg2: &mut TxContext)
43Pop
44LdConst[15](u64: 15)
45Abort
B9:
46CopyLoc[0](Arg0: &mut ValidatorSet)
47FreezeRef
48ImmBorrowLoc[1](Arg1: Validator)
49Call assert_no_pending_or_active_duplicates(&ValidatorSet, &Validator)
50ImmBorrowLoc[1](Arg1: Validator)
51Call validator::is_preactive(&Validator): bool
52BrFalse(54)
B10:
53Branch(60)
B11:
54MoveLoc[0](Arg0: &mut ValidatorSet)
55Pop
56MoveLoc[2](Arg2: &mut TxContext)
57Pop
58LdConst[7](u64: 7)
59Abort
B12:
60CopyLoc[0](Arg0: &mut ValidatorSet)
61MutBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
62ImmBorrowLoc[1](Arg1: Validator)
63Call validator::staking_pool_id(&Validator): ID
64MoveLoc[5](loc2: address)
65Call table::add<ID, address>(&mut Table<ID, address>, ID, address)
66MoveLoc[0](Arg0: &mut ValidatorSet)
67MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
68ImmBorrowLoc[1](Arg1: Validator)
69Call validator::sui_address(&Validator): address
70MoveLoc[1](Arg1: Validator)
71MoveLoc[2](Arg2: &mut TxContext)
72Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
73Call table::add<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address, ValidatorWrapper)
74Ret
}
public(friend) request_remove_validator_candidate(Arg0: &mut ValidatorSet, Arg1: &mut TxContext) {
L2: loc0: ID
L3: loc1: Validator
L4: loc2: address
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[4](loc2: address)
4CopyLoc[0](Arg0: &mut ValidatorSet)
5ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
6CopyLoc[4](loc2: address)
7Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
8BrFalse(10)
B1:
9Branch(16)
B2:
10MoveLoc[0](Arg0: &mut ValidatorSet)
11Pop
12MoveLoc[1](Arg1: &mut TxContext)
13Pop
14LdConst[8](u64: 8)
15Abort
B3:
16CopyLoc[0](Arg0: &mut ValidatorSet)
17MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
18MoveLoc[4](loc2: address)
19Call table::remove<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): ValidatorWrapper
20Call validator_wrapper::destroy(ValidatorWrapper): Validator
21StLoc[3](loc1: Validator)
22ImmBorrowLoc[3](loc1: Validator)
23Call validator::is_preactive(&Validator): bool
24BrFalse(26)
B4:
25Branch(32)
B5:
26MoveLoc[0](Arg0: &mut ValidatorSet)
27Pop
28MoveLoc[1](Arg1: &mut TxContext)
29Pop
30LdConst[7](u64: 7)
31Abort
B6:
32ImmBorrowLoc[3](loc1: Validator)
33Call validator::staking_pool_id(&Validator): ID
34StLoc[2](loc0: ID)
35CopyLoc[0](Arg0: &mut ValidatorSet)
36MutBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
37CopyLoc[2](loc0: ID)
38Call table::remove<ID, address>(&mut Table<ID, address>, ID): address
39Pop
40MutBorrowLoc[3](loc1: Validator)
41CopyLoc[1](Arg1: &mut TxContext)
42FreezeRef
43Call tx_context::epoch(&TxContext): u64
44Call validator::deactivate(&mut Validator, u64)
45MoveLoc[0](Arg0: &mut ValidatorSet)
46MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
47MoveLoc[2](loc0: ID)
48MoveLoc[3](loc1: Validator)
49MoveLoc[1](Arg1: &mut TxContext)
50Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
51Call table::add<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID, ValidatorWrapper)
52Ret
}
public(friend) request_add_validator(Arg0: &mut ValidatorSet, Arg1: &TxContext) {
L2: loc0: Validator
L3: loc1: address
B0:
0CopyLoc[1](Arg1: &TxContext)
1Call tx_context::sender(&TxContext): address
2StLoc[3](loc1: address)
3CopyLoc[0](Arg0: &mut ValidatorSet)
4ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
5CopyLoc[3](loc1: address)
6Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &mut ValidatorSet)
10Pop
11MoveLoc[1](Arg1: &TxContext)
12Pop
13LdConst[8](u64: 8)
14Abort
B3:
15CopyLoc[0](Arg0: &mut ValidatorSet)
16MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
17MoveLoc[3](loc1: address)
18Call table::remove<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): ValidatorWrapper
19Call validator_wrapper::destroy(ValidatorWrapper): Validator
20StLoc[2](loc0: Validator)
21CopyLoc[0](Arg0: &mut ValidatorSet)
22FreezeRef
23ImmBorrowLoc[2](loc0: Validator)
24Call assert_no_pending_or_active_duplicates(&ValidatorSet, &Validator)
25ImmBorrowLoc[2](loc0: Validator)
26Call validator::is_preactive(&Validator): bool
27BrFalse(29)
B4:
28Branch(35)
B5:
29MoveLoc[0](Arg0: &mut ValidatorSet)
30Pop
31MoveLoc[1](Arg1: &TxContext)
32Pop
33LdConst[7](u64: 7)
34Abort
B6:
35CopyLoc[0](Arg0: &mut ValidatorSet)
36FreezeRef
37ImmBorrowLoc[2](loc0: Validator)
38Call validator::total_stake(&Validator): u64
39MoveLoc[1](Arg1: &TxContext)
40Call can_join(&ValidatorSet, u64, &TxContext): bool
41BrFalse(43)
B7:
42Branch(47)
B8:
43MoveLoc[0](Arg0: &mut ValidatorSet)
44Pop
45LdConst[5](u64: 5)
46Abort
B9:
47MoveLoc[0](Arg0: &mut ValidatorSet)
48MutBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
49MoveLoc[2](loc0: Validator)
50Call table_vec::push_back<Validator>(&mut TableVec<Validator>, Validator)
51Ret
}
can_join(Arg0: &ValidatorSet, Arg1: u64, Arg2: &TxContext): bool {
L3: loc0: u64
L4: loc1: u64
B0:
0CopyLoc[0](Arg0: &ValidatorSet)
1MoveLoc[2](Arg2: &TxContext)
2Call get_voting_power_thresholds(&ValidatorSet, &TxContext): u64 * u64 * u64
3Pop
4Pop
5StLoc[4](loc1: u64)
6MoveLoc[0](Arg0: &ValidatorSet)
7ImmBorrowField[5](ValidatorSet.total_stake: u64)
8ReadRef
9CopyLoc[1](Arg1: u64)
10Add
11StLoc[3](loc0: u64)
12MoveLoc[1](Arg1: u64)
13MoveLoc[3](loc0: u64)
14Call voting_power::derive_raw_voting_power(u64, u64): u64
15MoveLoc[4](loc1: u64)
16Ge
17Ret
}
get_voting_power_thresholds(Arg0: &ValidatorSet, Arg1: &TxContext): u64 * u64 * u64 {
L2: loc0: u64
L3: loc1: u64
L4: loc2: u64
L5: loc3: u64
L6: loc4: u64
L7: loc5: u64
L8: loc6: u64
L9: loc7: u64
L10: loc8: VotingPowerAdmissionStartEpochKey
L11: loc9: u64
B0:
0LdFalse
1Pack[5](VotingPowerAdmissionStartEpochKey)
2StLoc[10](loc8: VotingPowerAdmissionStartEpochKey)
3CopyLoc[0](Arg0: &ValidatorSet)
4ImmBorrowField[6](ValidatorSet.extra_fields: Bag)
5CopyLoc[10](loc8: VotingPowerAdmissionStartEpochKey)
6Call bag::contains<VotingPowerAdmissionStartEpochKey>(&Bag, VotingPowerAdmissionStartEpochKey): bool
7BrFalse(15)
B1:
8MoveLoc[0](Arg0: &ValidatorSet)
9ImmBorrowField[6](ValidatorSet.extra_fields: Bag)
10MoveLoc[10](loc8: VotingPowerAdmissionStartEpochKey)
11Call bag::borrow<VotingPowerAdmissionStartEpochKey, u64>(&Bag, VotingPowerAdmissionStartEpochKey): &u64
12ReadRef
13StLoc[2](loc0: u64)
14Branch(22)
B2:
15MoveLoc[0](Arg0: &ValidatorSet)
16Pop
17CopyLoc[1](Arg1: &TxContext)
18Call tx_context::epoch(&TxContext): u64
19LdU64(1)
20Add
21StLoc[2](loc0: u64)
B3:
22MoveLoc[2](loc0: u64)
23StLoc[11](loc9: u64)
24MoveLoc[1](Arg1: &TxContext)
25Call tx_context::epoch(&TxContext): u64
26StLoc[9](loc7: u64)
27CopyLoc[9](loc7: u64)
28CopyLoc[11](loc9: u64)
29LdConst[14](u64: 14)
30Add
31Lt
32BrFalse(40)
B4:
33LdU64(12)
34LdU64(8)
35LdU64(4)
36StLoc[8](loc6: u64)
37StLoc[7](loc5: u64)
38StLoc[6](loc4: u64)
39Branch(67)
B5:
40MoveLoc[9](loc7: u64)
41MoveLoc[11](loc9: u64)
42LdU64(2)
43LdConst[14](u64: 14)
44Mul
45Add
46Lt
47BrFalse(55)
B6:
48LdU64(6)
49LdU64(4)
50LdU64(2)
51StLoc[5](loc3: u64)
52StLoc[4](loc2: u64)
53StLoc[3](loc1: u64)
54Branch(61)
B7:
55LdU64(3)
56LdU64(2)
57LdU64(1)
58StLoc[5](loc3: u64)
59StLoc[4](loc2: u64)
60StLoc[3](loc1: u64)
B8:
61MoveLoc[3](loc1: u64)
62MoveLoc[4](loc2: u64)
63MoveLoc[5](loc3: u64)
64StLoc[8](loc6: u64)
65StLoc[7](loc5: u64)
66StLoc[6](loc4: u64)
B9:
67MoveLoc[6](loc4: u64)
68MoveLoc[7](loc5: u64)
69MoveLoc[8](loc6: u64)
70Ret
}
public(friend) assert_no_pending_or_active_duplicates(Arg0: &ValidatorSet, Arg1: &Validator) {
B0:
0CopyLoc[0](Arg0: &ValidatorSet)
1CopyLoc[1](Arg1: &Validator)
2Call is_duplicate_with_active_validator(&ValidatorSet, &Validator): bool
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[1](Arg1: &Validator)
7Pop
8MoveLoc[0](Arg0: &ValidatorSet)
9Pop
10LdConst[2](u64: 2)
11Abort
B3:
12MoveLoc[0](Arg0: &ValidatorSet)
13MoveLoc[1](Arg1: &Validator)
14Call is_duplicate_with_pending_validator(&ValidatorSet, &Validator): bool
15Not
16BrFalse(18)
B4:
17Branch(20)
B5:
18LdConst[2](u64: 2)
19Abort
B6:
20Ret
}
public(friend) request_remove_validator(Arg0: &mut ValidatorSet, Arg1: &TxContext) {
L2: loc0: Option<u64>
L3: loc1: address
L4: loc2: u64
B0:
0MoveLoc[1](Arg1: &TxContext)
1Call tx_context::sender(&TxContext): address
2StLoc[3](loc1: address)
3CopyLoc[0](Arg0: &mut ValidatorSet)
4ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
5MoveLoc[3](loc1: address)
6Call find_validator(&vector<Validator>, address): Option<u64>
7StLoc[2](loc0: Option<u64>)
8ImmBorrowLoc[2](loc0: Option<u64>)
9Call option::is_some<u64>(&Option<u64>): bool
10BrFalse(12)
B1:
11Branch(18)
B2:
12MoveLoc[0](Arg0: &mut ValidatorSet)
13Pop
14MoveLoc[2](loc0: Option<u64>)
15Call option::destroy_none<u64>(Option<u64>)
16LdConst[4](u64: 4)
17Abort
B3:
18MoveLoc[2](loc0: Option<u64>)
19Call option::destroy_some<u64>(Option<u64>): u64
20StLoc[4](loc2: u64)
21CopyLoc[0](Arg0: &mut ValidatorSet)
22ImmBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
23ImmBorrowLoc[4](loc2: u64)
24Call vector::contains<u64>(&vector<u64>, &u64): bool
25Not
26BrFalse(28)
B4:
27Branch(32)
B5:
28MoveLoc[0](Arg0: &mut ValidatorSet)
29Pop
30LdConst[10](u64: 11)
31Abort
B6:
32MoveLoc[0](Arg0: &mut ValidatorSet)
33MutBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
34MoveLoc[4](loc2: u64)
35VecPushBack(20)
36Ret
}
public(friend) request_add_stake(Arg0: &mut ValidatorSet, Arg1: address, Arg2: Balance<SUI>, Arg3: &mut TxContext): StakedSui {
B0:
0ImmBorrowLoc[2](Arg2: Balance<SUI>)
1Call balance::value<SUI>(&Balance<SUI>): u64
2LdConst[20](u64: 1000..)
3Ge
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut ValidatorSet)
7Pop
8MoveLoc[3](Arg3: &mut TxContext)
9Pop
10LdConst[9](u64: 10)
11Abort
B3:
12MoveLoc[0](Arg0: &mut ValidatorSet)
13MoveLoc[1](Arg1: address)
14Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
15MoveLoc[2](Arg2: Balance<SUI>)
16CopyLoc[3](Arg3: &mut TxContext)
17FreezeRef
18Call tx_context::sender(&TxContext): address
19MoveLoc[3](Arg3: &mut TxContext)
20Call validator::request_add_stake(&mut Validator, Balance<SUI>, address, &mut TxContext): StakedSui
21Ret
}
public(friend) request_withdraw_stake(Arg0: &mut ValidatorSet, Arg1: StakedSui, Arg2: &TxContext): Balance<SUI> {
L3: loc0: &mut Validator
L4: loc1: ID
L5: loc2: address
B0:
0ImmBorrowLoc[1](Arg1: StakedSui)
1Call staking_pool::pool_id(&StakedSui): ID
2StLoc[4](loc1: ID)
3CopyLoc[0](Arg0: &mut ValidatorSet)
4ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
5CopyLoc[4](loc1: ID)
6Call table::contains<ID, address>(&Table<ID, address>, ID): bool
7BrFalse(20)
B1:
8CopyLoc[0](Arg0: &mut ValidatorSet)
9ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
10ImmBorrowLoc[1](Arg1: StakedSui)
11Call staking_pool::pool_id(&StakedSui): ID
12Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
13ReadRef
14StLoc[5](loc2: address)
15MoveLoc[0](Arg0: &mut ValidatorSet)
16MoveLoc[5](loc2: address)
17Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
18StLoc[3](loc0: &mut Validator)
19Branch(38)
B2:
20CopyLoc[0](Arg0: &mut ValidatorSet)
21ImmBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
22CopyLoc[4](loc1: ID)
23Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
24BrFalse(26)
B3:
25Branch(32)
B4:
26MoveLoc[0](Arg0: &mut ValidatorSet)
27Pop
28MoveLoc[2](Arg2: &TxContext)
29Pop
30LdConst[3](u64: 3)
31Abort
B5:
32MoveLoc[0](Arg0: &mut ValidatorSet)
33MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
34MoveLoc[4](loc1: ID)
35Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
36Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
37StLoc[3](loc0: &mut Validator)
B6:
38MoveLoc[3](loc0: &mut Validator)
39MoveLoc[1](Arg1: StakedSui)
40MoveLoc[2](Arg2: &TxContext)
41Call validator::request_withdraw_stake(&mut Validator, StakedSui, &TxContext): Balance<SUI>
42Ret
}
public(friend) convert_to_fungible_staked_sui(Arg0: &mut ValidatorSet, Arg1: StakedSui, Arg2: &mut TxContext): FungibleStakedSui {
L3: loc0: &mut Validator
L4: loc1: ID
L5: loc2: address
B0:
0ImmBorrowLoc[1](Arg1: StakedSui)
1Call staking_pool::pool_id(&StakedSui): ID
2StLoc[4](loc1: ID)
3CopyLoc[0](Arg0: &mut ValidatorSet)
4ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
5CopyLoc[4](loc1: ID)
6Call table::contains<ID, address>(&Table<ID, address>, ID): bool
7BrFalse(19)
B1:
8CopyLoc[0](Arg0: &mut ValidatorSet)
9ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
10MoveLoc[4](loc1: ID)
11Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
12ReadRef
13StLoc[5](loc2: address)
14MoveLoc[0](Arg0: &mut ValidatorSet)
15MoveLoc[5](loc2: address)
16Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
17StLoc[3](loc0: &mut Validator)
18Branch(37)
B2:
19CopyLoc[0](Arg0: &mut ValidatorSet)
20ImmBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
21CopyLoc[4](loc1: ID)
22Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
23BrFalse(25)
B3:
24Branch(31)
B4:
25MoveLoc[0](Arg0: &mut ValidatorSet)
26Pop
27MoveLoc[2](Arg2: &mut TxContext)
28Pop
29LdConst[3](u64: 3)
30Abort
B5:
31MoveLoc[0](Arg0: &mut ValidatorSet)
32MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
33MoveLoc[4](loc1: ID)
34Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
35Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
36StLoc[3](loc0: &mut Validator)
B6:
37MoveLoc[3](loc0: &mut Validator)
38MoveLoc[1](Arg1: StakedSui)
39MoveLoc[2](Arg2: &mut TxContext)
40Call validator::convert_to_fungible_staked_sui(&mut Validator, StakedSui, &mut TxContext): FungibleStakedSui
41Ret
}
public(friend) redeem_fungible_staked_sui(Arg0: &mut ValidatorSet, Arg1: FungibleStakedSui, Arg2: &TxContext): Balance<SUI> {
L3: loc0: &mut Validator
L4: loc1: ID
L5: loc2: address
B0:
0ImmBorrowLoc[1](Arg1: FungibleStakedSui)
1Call staking_pool::fungible_staked_sui_pool_id(&FungibleStakedSui): ID
2StLoc[4](loc1: ID)
3CopyLoc[0](Arg0: &mut ValidatorSet)
4ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
5CopyLoc[4](loc1: ID)
6Call table::contains<ID, address>(&Table<ID, address>, ID): bool
7BrFalse(19)
B1:
8CopyLoc[0](Arg0: &mut ValidatorSet)
9ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
10MoveLoc[4](loc1: ID)
11Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
12ReadRef
13StLoc[5](loc2: address)
14MoveLoc[0](Arg0: &mut ValidatorSet)
15MoveLoc[5](loc2: address)
16Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
17StLoc[3](loc0: &mut Validator)
18Branch(37)
B2:
19CopyLoc[0](Arg0: &mut ValidatorSet)
20ImmBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
21CopyLoc[4](loc1: ID)
22Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
23BrFalse(25)
B3:
24Branch(31)
B4:
25MoveLoc[0](Arg0: &mut ValidatorSet)
26Pop
27MoveLoc[2](Arg2: &TxContext)
28Pop
29LdConst[3](u64: 3)
30Abort
B5:
31MoveLoc[0](Arg0: &mut ValidatorSet)
32MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
33MoveLoc[4](loc1: ID)
34Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
35Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
36StLoc[3](loc0: &mut Validator)
B6:
37MoveLoc[3](loc0: &mut Validator)
38MoveLoc[1](Arg1: FungibleStakedSui)
39MoveLoc[2](Arg2: &TxContext)
40Call validator::redeem_fungible_staked_sui(&mut Validator, FungibleStakedSui, &TxContext): Balance<SUI>
41Ret
}
public(friend) advance_epoch(Arg0: &mut ValidatorSet, Arg1: &mut Balance<SUI>, Arg2: &mut Balance<SUI>, Arg3: &mut VecMap<address, VecSet<address>>, Arg4: u64, Arg5: u64, Arg6: &mut TxContext) {
L7: loc0: u64
L8: loc1: u64
L9: loc2: u64
L10: loc3: vector<u64>
L11: loc4: vector<u64>
L12: loc5: u64
L13: loc6: u64
L14: loc7: u64
L15: loc8: u64
L16: loc9: u64
L17: loc10: u64
L18: loc11: VecMap<u64, u64>
L19: loc12: VecMap<u64, u64>
L20: loc13: VotingPowerAdmissionStartEpochKey
L21: loc14: u64
L22: loc15: u64
L23: loc16: vector<address>
L24: loc17: u64
L25: loc18: u64
L26: loc19: u64
L27: loc20: u64
L28: loc21: u64
L29: loc22: u64
L30: loc23: u64
L31: loc24: vector<u64>
L32: loc25: vector<u64>
L33: loc26: &mut vector<Validator>
L34: loc27: &mut vector<Validator>
L35: loc28: &mut vector<Validator>
B0:
0CopyLoc[6](Arg6: &mut TxContext)
1FreezeRef
2Call tx_context::epoch(&TxContext): u64
3LdU64(1)
4Add
5StLoc[21](loc14: u64)
6Call voting_power::total_voting_power(): u64
7StLoc[30](loc23: u64)
8LdFalse
9Pack[5](VotingPowerAdmissionStartEpochKey)
10StLoc[20](loc13: VotingPowerAdmissionStartEpochKey)
11CopyLoc[0](Arg0: &mut ValidatorSet)
12ImmBorrowField[6](ValidatorSet.extra_fields: Bag)
13CopyLoc[20](loc13: VotingPowerAdmissionStartEpochKey)
14Call bag::contains<VotingPowerAdmissionStartEpochKey>(&Bag, VotingPowerAdmissionStartEpochKey): bool
15Not
16BrFalse(24)
B1:
17CopyLoc[0](Arg0: &mut ValidatorSet)
18MutBorrowField[6](ValidatorSet.extra_fields: Bag)
19MoveLoc[20](loc13: VotingPowerAdmissionStartEpochKey)
20CopyLoc[6](Arg6: &mut TxContext)
21FreezeRef
22Call tx_context::epoch(&TxContext): u64
23Call bag::add<VotingPowerAdmissionStartEpochKey, u64>(&mut Bag, VotingPowerAdmissionStartEpochKey, u64)
B2:
24CopyLoc[0](Arg0: &mut ValidatorSet)
25ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
26CopyLoc[30](loc23: u64)
27CopyLoc[1](Arg1: &mut Balance<SUI>)
28FreezeRef
29Call balance::value<SUI>(&Balance<SUI>): u64
30CopyLoc[2](Arg2: &mut Balance<SUI>)
31FreezeRef
32Call balance::value<SUI>(&Balance<SUI>): u64
33Call compute_unadjusted_reward_distribution(&vector<Validator>, u64, u64, u64): vector<u64> * vector<u64>
34StLoc[32](loc25: vector<u64>)
35StLoc[31](loc24: vector<u64>)
36CopyLoc[0](Arg0: &mut ValidatorSet)
37FreezeRef
38CopyLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
39ReadRef
40Call compute_slashed_validators(&ValidatorSet, VecMap<address, VecSet<address>>): vector<address>
41StLoc[23](loc16: vector<address>)
42CopyLoc[0](Arg0: &mut ValidatorSet)
43ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
44ImmBorrowLoc[23](loc16: vector<address>)
45Call sum_voting_power_by_addresses(&vector<Validator>, &vector<address>): u64
46StLoc[27](loc20: u64)
47CopyLoc[0](Arg0: &mut ValidatorSet)
48ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
49ImmBorrowLoc[23](loc16: vector<address>)
50Call get_validator_indices(&vector<Validator>, &vector<address>): vector<u64>
51MoveLoc[4](Arg4: u64)
52ImmBorrowLoc[31](loc24: vector<u64>)
53ImmBorrowLoc[32](loc25: vector<u64>)
54Call compute_reward_adjustments(vector<u64>, u64, &vector<u64>, &vector<u64>): u64 * VecMap<u64, u64> * u64 * VecMap<u64, u64>
55StLoc[19](loc12: VecMap<u64, u64>)
56StLoc[29](loc22: u64)
57StLoc[18](loc11: VecMap<u64, u64>)
58StLoc[28](loc21: u64)
59CopyLoc[0](Arg0: &mut ValidatorSet)
60ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
61MoveLoc[30](loc23: u64)
62MoveLoc[27](loc20: u64)
63MoveLoc[31](loc24: vector<u64>)
64MoveLoc[32](loc25: vector<u64>)
65MoveLoc[28](loc21: u64)
66MoveLoc[18](loc11: VecMap<u64, u64>)
67MoveLoc[29](loc22: u64)
68MoveLoc[19](loc12: VecMap<u64, u64>)
69Call compute_adjusted_reward_distribution(&vector<Validator>, u64, u64, vector<u64>, vector<u64>, u64, VecMap<u64, u64>, u64, VecMap<u64, u64>): vector<u64> * vector<u64>
70StLoc[11](loc4: vector<u64>)
71StLoc[10](loc3: vector<u64>)
72CopyLoc[0](Arg0: &mut ValidatorSet)
73MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
74ImmBorrowLoc[10](loc3: vector<u64>)
75ImmBorrowLoc[11](loc4: vector<u64>)
76MoveLoc[1](Arg1: &mut Balance<SUI>)
77MoveLoc[2](Arg2: &mut Balance<SUI>)
78CopyLoc[6](Arg6: &mut TxContext)
79Call distribute_reward(&mut vector<Validator>, &vector<u64>, &vector<u64>, &mut Balance<SUI>, &mut Balance<SUI>, &mut TxContext)
80CopyLoc[0](Arg0: &mut ValidatorSet)
81MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
82StLoc[33](loc26: &mut vector<Validator>)
83CopyLoc[33](loc26: &mut vector<Validator>)
84FreezeRef
85VecLen(58)
86StLoc[9](loc2: u64)
87LdU64(0)
88StLoc[16](loc9: u64)
89MoveLoc[9](loc2: u64)
90StLoc[26](loc19: u64)
B3:
91CopyLoc[16](loc9: u64)
92CopyLoc[26](loc19: u64)
93Lt
94BrFalse(106)
B4:
95CopyLoc[16](loc9: u64)
96StLoc[17](loc10: u64)
97CopyLoc[33](loc26: &mut vector<Validator>)
98MoveLoc[17](loc10: u64)
99VecMutBorrow(58)
100Call validator::adjust_stake_and_gas_price(&mut Validator)
101MoveLoc[16](loc9: u64)
102LdU64(1)
103Add
104StLoc[16](loc9: u64)
105Branch(91)
B5:
106MoveLoc[33](loc26: &mut vector<Validator>)
107Pop
108CopyLoc[0](Arg0: &mut ValidatorSet)
109MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
110StLoc[34](loc27: &mut vector<Validator>)
111CopyLoc[34](loc27: &mut vector<Validator>)
112FreezeRef
113VecLen(58)
114StLoc[7](loc0: u64)
115LdU64(0)
116StLoc[12](loc5: u64)
117MoveLoc[7](loc0: u64)
118StLoc[24](loc17: u64)
B6:
119CopyLoc[12](loc5: u64)
120CopyLoc[24](loc17: u64)
121Lt
122BrFalse(136)
B7:
123CopyLoc[12](loc5: u64)
124StLoc[13](loc6: u64)
125CopyLoc[34](loc27: &mut vector<Validator>)
126MoveLoc[13](loc6: u64)
127VecMutBorrow(58)
128CopyLoc[6](Arg6: &mut TxContext)
129FreezeRef
130Call validator::process_pending_stakes_and_withdraws(&mut Validator, &TxContext)
131MoveLoc[12](loc5: u64)
132LdU64(1)
133Add
134StLoc[12](loc5: u64)
135Branch(119)
B8:
136MoveLoc[34](loc27: &mut vector<Validator>)
137Pop
138MoveLoc[21](loc14: u64)
139CopyLoc[0](Arg0: &mut ValidatorSet)
140ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
141ImmBorrowLoc[10](loc3: vector<u64>)
142ImmBorrowLoc[11](loc4: vector<u64>)
143CopyLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
144FreezeRef
145ImmBorrowLoc[23](loc16: vector<address>)
146Call emit_validator_epoch_events(u64, &vector<Validator>, &vector<u64>, &vector<u64>, &VecMap<address, VecSet<address>>, &vector<address>)
147CopyLoc[0](Arg0: &mut ValidatorSet)
148CopyLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
149CopyLoc[6](Arg6: &mut TxContext)
150Call process_pending_removals(&mut ValidatorSet, &mut VecMap<address, VecSet<address>>, &mut TxContext)
151CopyLoc[0](Arg0: &mut ValidatorSet)
152MoveLoc[5](Arg5: u64)
153MoveLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
154MoveLoc[6](Arg6: &mut TxContext)
155Call update_validator_positions_and_calculate_total_stake(&mut ValidatorSet, u64, &mut VecMap<address, VecSet<address>>, &mut TxContext): u64
156StLoc[22](loc15: u64)
157CopyLoc[22](loc15: u64)
158CopyLoc[0](Arg0: &mut ValidatorSet)
159MutBorrowField[5](ValidatorSet.total_stake: u64)
160WriteRef
161CopyLoc[0](Arg0: &mut ValidatorSet)
162MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
163MoveLoc[22](loc15: u64)
164Call voting_power::set_voting_power(&mut vector<Validator>, u64)
165MoveLoc[0](Arg0: &mut ValidatorSet)
166MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
167StLoc[35](loc28: &mut vector<Validator>)
168CopyLoc[35](loc28: &mut vector<Validator>)
169FreezeRef
170VecLen(58)
171StLoc[8](loc1: u64)
172LdU64(0)
173StLoc[14](loc7: u64)
174MoveLoc[8](loc1: u64)
175StLoc[25](loc18: u64)
B9:
176CopyLoc[14](loc7: u64)
177CopyLoc[25](loc18: u64)
178Lt
179BrFalse(191)
B10:
180CopyLoc[14](loc7: u64)
181StLoc[15](loc8: u64)
182CopyLoc[35](loc28: &mut vector<Validator>)
183MoveLoc[15](loc8: u64)
184VecMutBorrow(58)
185Call validator::effectuate_staged_metadata(&mut Validator)
186MoveLoc[14](loc7: u64)
187LdU64(1)
188Add
189StLoc[14](loc7: u64)
190Branch(176)
B11:
191MoveLoc[35](loc28: &mut vector<Validator>)
192Pop
193Ret
}
update_validator_positions_and_calculate_total_stake(Arg0: &mut ValidatorSet, Arg1: u64, Arg2: &mut VecMap<address, VecSet<address>>, Arg3: &mut TxContext): u64 {
L4: loc0: u64
L5: loc1: u64
L6: loc2: Validator
L7: loc3: &mut vector<Validator>
L8: loc4: u64
L9: loc5: u64
L10: loc6: u64
L11: loc7: u64
L12: loc8: u64
L13: loc9: u64
L14: loc10: u64
L15: loc11: u64
L16: loc12: &mut u64
L17: loc13: vector<Validator>
L18: loc14: u64
L19: loc15: u64
L20: loc16: u64
L21: loc17: u64
L22: loc18: u64
L23: loc19: u64
L24: loc20: vector<Validator>
L25: loc21: vector<Validator>
L26: loc22: Validator
L27: loc23: Validator
L28: loc24: Validator
L29: loc25: address
L30: loc26: &Validator
L31: loc27: u64
L32: loc28: u64
L33: loc29: u64
B0:
0VecPack(58, 0)
1StLoc[24](loc20: vector<Validator>)
2CopyLoc[0](Arg0: &mut ValidatorSet)
3ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
4Call table_vec::length<Validator>(&TableVec<Validator>): u64
5StLoc[5](loc1: u64)
6LdU64(0)
7StLoc[12](loc8: u64)
8MoveLoc[5](loc1: u64)
9StLoc[22](loc18: u64)
B1:
10CopyLoc[12](loc8: u64)
11CopyLoc[22](loc18: u64)
12Lt
13BrFalse(32)
B2:
14CopyLoc[12](loc8: u64)
15StLoc[10](loc6: u64)
16MutBorrowLoc[24](loc20: vector<Validator>)
17StLoc[7](loc3: &mut vector<Validator>)
18MoveLoc[10](loc6: u64)
19Pop
20CopyLoc[0](Arg0: &mut ValidatorSet)
21MutBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
22Call table_vec::pop_back<Validator>(&mut TableVec<Validator>): Validator
23StLoc[6](loc2: Validator)
24MoveLoc[7](loc3: &mut vector<Validator>)
25MoveLoc[6](loc2: Validator)
26VecPushBack(58)
27MoveLoc[12](loc8: u64)
28LdU64(1)
29Add
30StLoc[12](loc8: u64)
31Branch(10)
B3:
32MoveLoc[24](loc20: vector<Validator>)
33StLoc[17](loc13: vector<Validator>)
34ImmBorrowLoc[17](loc13: vector<Validator>)
35Call calculate_total_stakes(&vector<Validator>): u64
36StLoc[18](loc14: u64)
37CopyLoc[0](Arg0: &mut ValidatorSet)
38ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
39Call calculate_total_stakes(&vector<Validator>): u64
40MoveLoc[18](loc14: u64)
41Add
42StLoc[13](loc9: u64)
43CopyLoc[0](Arg0: &mut ValidatorSet)
44FreezeRef
45CopyLoc[3](Arg3: &mut TxContext)
46FreezeRef
47Call get_voting_power_thresholds(&ValidatorSet, &TxContext): u64 * u64 * u64
48StLoc[32](loc28: u64)
49StLoc[14](loc10: u64)
50StLoc[15](loc11: u64)
51LdU64(0)
52StLoc[23](loc19: u64)
53CopyLoc[0](Arg0: &mut ValidatorSet)
54ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
55VecLen(58)
56StLoc[9](loc5: u64)
B4:
57CopyLoc[9](loc5: u64)
58LdU64(0)
59Gt
60BrFalse(164)
B5:
61MoveLoc[9](loc5: u64)
62LdU64(1)
63Sub
64StLoc[9](loc5: u64)
65CopyLoc[0](Arg0: &mut ValidatorSet)
66ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
67CopyLoc[9](loc5: u64)
68VecImmBorrow(58)
69StLoc[30](loc26: &Validator)
70CopyLoc[30](loc26: &Validator)
71Call validator::sui_address(&Validator): address
72StLoc[29](loc25: address)
73MoveLoc[30](loc26: &Validator)
74Call validator::total_stake(&Validator): u64
75CopyLoc[13](loc9: u64)
76Call voting_power::derive_raw_voting_power(u64, u64): u64
77StLoc[33](loc29: u64)
78CopyLoc[33](loc29: u64)
79CopyLoc[14](loc10: u64)
80Ge
81BrFalse(95)
B6:
82Branch(83)
B7:
83CopyLoc[0](Arg0: &mut ValidatorSet)
84ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
85ImmBorrowLoc[29](loc25: address)
86Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
87BrFalse(57)
B8:
88CopyLoc[0](Arg0: &mut ValidatorSet)
89MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
90ImmBorrowLoc[29](loc25: address)
91Call vec_map::remove<address, u64>(&mut VecMap<address, u64>, &address): address * u64
92Pop
93Pop
94Branch(57)
B9:
95MoveLoc[33](loc29: u64)
96CopyLoc[32](loc28: u64)
97Ge
98BrFalse(147)
B10:
99CopyLoc[0](Arg0: &mut ValidatorSet)
100ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
101ImmBorrowLoc[29](loc25: address)
102Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
103BrFalse(119)
B11:
104CopyLoc[0](Arg0: &mut ValidatorSet)
105MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
106ImmBorrowLoc[29](loc25: address)
107Call vec_map::get_mut<address, u64>(&mut VecMap<address, u64>, &address): &mut u64
108StLoc[16](loc12: &mut u64)
109CopyLoc[16](loc12: &mut u64)
110ReadRef
111LdU64(1)
112Add
113CopyLoc[16](loc12: &mut u64)
114WriteRef
115MoveLoc[16](loc12: &mut u64)
116ReadRef
117StLoc[8](loc4: u64)
118Branch(126)
B12:
119CopyLoc[0](Arg0: &mut ValidatorSet)
120MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
121MoveLoc[29](loc25: address)
122LdU64(1)
123Call vec_map::insert<address, u64>(&mut VecMap<address, u64>, address, u64)
124LdU64(1)
125StLoc[8](loc4: u64)
B13:
126MoveLoc[8](loc4: u64)
127CopyLoc[1](Arg1: u64)
128Gt
129BrFalse(57)
B14:
130CopyLoc[0](Arg0: &mut ValidatorSet)
131MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
132CopyLoc[9](loc5: u64)
133Call vector::remove<Validator>(&mut vector<Validator>, u64): Validator
134StLoc[26](loc22: Validator)
135CopyLoc[0](Arg0: &mut ValidatorSet)
136MoveLoc[26](loc22: Validator)
137CopyLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
138LdFalse
139CopyLoc[3](Arg3: &mut TxContext)
140Call process_validator_departure(&mut ValidatorSet, Validator, &mut VecMap<address, VecSet<address>>, bool, &mut TxContext): u64
141StLoc[19](loc15: u64)
142MoveLoc[23](loc19: u64)
143MoveLoc[19](loc15: u64)
144Add
145StLoc[23](loc19: u64)
146Branch(57)
B15:
147CopyLoc[0](Arg0: &mut ValidatorSet)
148MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
149CopyLoc[9](loc5: u64)
150Call vector::remove<Validator>(&mut vector<Validator>, u64): Validator
151StLoc[27](loc23: Validator)
152CopyLoc[0](Arg0: &mut ValidatorSet)
153MoveLoc[27](loc23: Validator)
154CopyLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
155LdFalse
156CopyLoc[3](Arg3: &mut TxContext)
157Call process_validator_departure(&mut ValidatorSet, Validator, &mut VecMap<address, VecSet<address>>, bool, &mut TxContext): u64
158StLoc[20](loc16: u64)
159MoveLoc[23](loc19: u64)
160MoveLoc[20](loc16: u64)
161Add
162StLoc[23](loc19: u64)
163Branch(57)
B16:
164MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
165Pop
166MoveLoc[17](loc13: vector<Validator>)
167StLoc[25](loc21: vector<Validator>)
168MutBorrowLoc[25](loc21: vector<Validator>)
169Call vector::reverse<Validator>(&mut vector<Validator>)
170ImmBorrowLoc[25](loc21: vector<Validator>)
171VecLen(58)
172StLoc[4](loc0: u64)
173LdU64(0)
174StLoc[11](loc7: u64)
175MoveLoc[4](loc0: u64)
176StLoc[21](loc17: u64)
B17:
177CopyLoc[11](loc7: u64)
178CopyLoc[21](loc17: u64)
179Lt
180BrFalse(232)
B18:
181Branch(182)
B19:
182CopyLoc[11](loc7: u64)
183Pop
184MutBorrowLoc[25](loc21: vector<Validator>)
185VecPopBack(58)
186StLoc[28](loc24: Validator)
187ImmBorrowLoc[28](loc24: Validator)
188Call validator::total_stake(&Validator): u64
189StLoc[31](loc27: u64)
190CopyLoc[31](loc27: u64)
191CopyLoc[13](loc9: u64)
192Call voting_power::derive_raw_voting_power(u64, u64): u64
193CopyLoc[15](loc11: u64)
194Ge
195BrFalse(215)
B20:
196MutBorrowLoc[28](loc24: Validator)
197CopyLoc[3](Arg3: &mut TxContext)
198FreezeRef
199Call tx_context::epoch(&TxContext): u64
200Call validator::activate(&mut Validator, u64)
201CopyLoc[3](Arg3: &mut TxContext)
202FreezeRef
203Call tx_context::epoch(&TxContext): u64
204ImmBorrowLoc[28](loc24: Validator)
205Call validator::sui_address(&Validator): address
206ImmBorrowLoc[28](loc24: Validator)
207Call validator::staking_pool_id(&Validator): ID
208Pack[3](ValidatorJoinEvent)
209Call event::emit<ValidatorJoinEvent>(ValidatorJoinEvent)
210CopyLoc[0](Arg0: &mut ValidatorSet)
211MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
212MoveLoc[28](loc24: Validator)
213VecPushBack(58)
214Branch(227)
B21:
215CopyLoc[0](Arg0: &mut ValidatorSet)
216MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
217ImmBorrowLoc[28](loc24: Validator)
218Call validator::sui_address(&Validator): address
219MoveLoc[28](loc24: Validator)
220CopyLoc[3](Arg3: &mut TxContext)
221Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
222Call table::add<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address, ValidatorWrapper)
223MoveLoc[23](loc19: u64)
224MoveLoc[31](loc27: u64)
225Add
226StLoc[23](loc19: u64)
B22:
227MoveLoc[11](loc7: u64)
228LdU64(1)
229Add
230StLoc[11](loc7: u64)
231Branch(177)
B23:
232MoveLoc[0](Arg0: &mut ValidatorSet)
233Pop
234MoveLoc[3](Arg3: &mut TxContext)
235Pop
236MoveLoc[25](loc21: vector<Validator>)
237VecUnpack(58, 0)
238MoveLoc[13](loc9: u64)
239MoveLoc[23](loc19: u64)
240Sub
241Ret
}
public derive_reference_gas_price(Arg0: &ValidatorSet): u64 {
L1: loc0: u64
L2: loc1: Entry<u64>
L3: loc2: &mut vector<Entry<u64>>
L4: loc3: &Validator
L5: loc4: u64
L6: loc5: u64
L7: loc6: PriorityQueue<u64>
L8: loc7: vector<Entry<u64>>
L9: loc8: u64
L10: loc9: u64
L11: loc10: u64
L12: loc11: u64
L13: loc12: &vector<Validator>
L14: loc13: &Validator
L15: loc14: &vector<Validator>
L16: loc15: u64
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2StLoc[13](loc12: &vector<Validator>)
3VecPack(114, 0)
4StLoc[8](loc7: vector<Entry<u64>>)
5MoveLoc[13](loc12: &vector<Validator>)
6StLoc[15](loc14: &vector<Validator>)
7CopyLoc[15](loc14: &vector<Validator>)
8VecLen(58)
9StLoc[1](loc0: u64)
10LdU64(0)
11StLoc[6](loc5: u64)
12MoveLoc[1](loc0: u64)
13StLoc[10](loc9: u64)
B1:
14CopyLoc[6](loc5: u64)
15CopyLoc[10](loc9: u64)
16Lt
17BrFalse(42)
B2:
18CopyLoc[6](loc5: u64)
19StLoc[5](loc4: u64)
20CopyLoc[15](loc14: &vector<Validator>)
21MoveLoc[5](loc4: u64)
22VecImmBorrow(58)
23StLoc[4](loc3: &Validator)
24MutBorrowLoc[8](loc7: vector<Entry<u64>>)
25StLoc[3](loc2: &mut vector<Entry<u64>>)
26MoveLoc[4](loc3: &Validator)
27StLoc[14](loc13: &Validator)
28CopyLoc[14](loc13: &Validator)
29Call validator::gas_price(&Validator): u64
30MoveLoc[14](loc13: &Validator)
31Call validator::voting_power(&Validator): u64
32Call priority_queue::new_entry<u64>(u64, u64): Entry<u64>
33StLoc[2](loc1: Entry<u64>)
34MoveLoc[3](loc2: &mut vector<Entry<u64>>)
35MoveLoc[2](loc1: Entry<u64>)
36VecPushBack(114)
37MoveLoc[6](loc5: u64)
38LdU64(1)
39Add
40StLoc[6](loc5: u64)
41Branch(14)
B3:
42MoveLoc[15](loc14: &vector<Validator>)
43Pop
44MoveLoc[8](loc7: vector<Entry<u64>>)
45Call priority_queue::new<u64>(vector<Entry<u64>>): PriorityQueue<u64>
46StLoc[7](loc6: PriorityQueue<u64>)
47LdU64(0)
48StLoc[11](loc10: u64)
49Call voting_power::total_voting_power(): u64
50Call voting_power::quorum_threshold(): u64
51Sub
52StLoc[12](loc11: u64)
53LdU64(0)
54StLoc[9](loc8: u64)
B4:
55CopyLoc[11](loc10: u64)
56CopyLoc[12](loc11: u64)
57Lt
58BrFalse(68)
B5:
59MutBorrowLoc[7](loc6: PriorityQueue<u64>)
60Call priority_queue::pop_max<u64>(&mut PriorityQueue<u64>): u64 * u64
61StLoc[16](loc15: u64)
62StLoc[9](loc8: u64)
63MoveLoc[11](loc10: u64)
64MoveLoc[16](loc15: u64)
65Add
66StLoc[11](loc10: u64)
67Branch(55)
B6:
68MoveLoc[9](loc8: u64)
69Ret
}
public total_stake(Arg0: &ValidatorSet): u64 {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[5](ValidatorSet.total_stake: u64)
2ReadRef
3Ret
}
public validator_total_stake_amount(Arg0: &ValidatorSet, Arg1: address): u64 {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1MoveLoc[1](Arg1: address)
2Call active_validator(&ValidatorSet, address): &Validator
3Call validator::total_stake(&Validator): u64
4Ret
}
public validator_stake_amount(Arg0: &ValidatorSet, Arg1: address): u64 {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1MoveLoc[1](Arg1: address)
2Call active_validator(&ValidatorSet, address): &Validator
3Call validator::total_stake(&Validator): u64
4Ret
}
public validator_voting_power(Arg0: &ValidatorSet, Arg1: address): u64 {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1MoveLoc[1](Arg1: address)
2Call active_validator(&ValidatorSet, address): &Validator
3Call validator::voting_power(&Validator): u64
4Ret
}
public validator_staking_pool_id(Arg0: &ValidatorSet, Arg1: address): ID {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1MoveLoc[1](Arg1: address)
2Call active_validator(&ValidatorSet, address): &Validator
3Call validator::staking_pool_id(&Validator): ID
4Ret
}
public staking_pool_mappings(Arg0: &ValidatorSet): &Table<ID, address> {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
2Ret
}
public validator_address_by_pool_id(Arg0: &mut ValidatorSet, Arg1: &ID): address {
L2: loc0: address
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
2CopyLoc[1](Arg1: &ID)
3ReadRef
4Call table::contains<ID, address>(&Table<ID, address>, ID): bool
5BrFalse(14)
B1:
6MoveLoc[0](Arg0: &mut ValidatorSet)
7ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
8MoveLoc[1](Arg1: &ID)
9ReadRef
10Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
11ReadRef
12StLoc[2](loc0: address)
13Branch(23)
B2:
14MoveLoc[0](Arg0: &mut ValidatorSet)
15MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
16MoveLoc[1](Arg1: &ID)
17ReadRef
18Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
19Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
20FreezeRef
21Call validator::sui_address(&Validator): address
22StLoc[2](loc0: address)
B3:
23MoveLoc[2](loc0: address)
24Ret
}
public(friend) pool_exchange_rates(Arg0: &mut ValidatorSet, Arg1: ID): &Table<u64, PoolTokenExchangeRate> {
L2: loc0: &Validator
L3: loc1: address
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
2CopyLoc[1](Arg1: ID)
3Call table::contains<ID, address>(&Table<ID, address>, ID): bool
4BrFalse(16)
B1:
5CopyLoc[0](Arg0: &mut ValidatorSet)
6ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
7MoveLoc[1](Arg1: ID)
8Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
9ReadRef
10StLoc[3](loc1: address)
11MoveLoc[0](Arg0: &mut ValidatorSet)
12MoveLoc[3](loc1: address)
13Call any_validator(&mut ValidatorSet, address): &Validator
14StLoc[2](loc0: &Validator)
15Branch(23)
B2:
16MoveLoc[0](Arg0: &mut ValidatorSet)
17MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
18MoveLoc[1](Arg1: ID)
19Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
20Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
21FreezeRef
22StLoc[2](loc0: &Validator)
B3:
23MoveLoc[2](loc0: &Validator)
24Call validator::get_staking_pool_ref(&Validator): &StakingPool
25Call staking_pool::exchange_rates(&StakingPool): &Table<u64, PoolTokenExchangeRate>
26Ret
}
public(friend) validator_by_pool_id(Arg0: &mut ValidatorSet, Arg1: ID): &Validator {
L2: loc0: &Validator
L3: loc1: address
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
2CopyLoc[1](Arg1: ID)
3Call table::contains<ID, address>(&Table<ID, address>, ID): bool
4BrFalse(16)
B1:
5CopyLoc[0](Arg0: &mut ValidatorSet)
6ImmBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
7MoveLoc[1](Arg1: ID)
8Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
9ReadRef
10StLoc[3](loc1: address)
11MoveLoc[0](Arg0: &mut ValidatorSet)
12MoveLoc[3](loc1: address)
13Call any_validator(&mut ValidatorSet, address): &Validator
14StLoc[2](loc0: &Validator)
15Branch(23)
B2:
16MoveLoc[0](Arg0: &mut ValidatorSet)
17MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
18MoveLoc[1](Arg1: ID)
19Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
20Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
21FreezeRef
22StLoc[2](loc0: &Validator)
B3:
23MoveLoc[2](loc0: &Validator)
24Ret
}
public(friend) next_epoch_validator_count(Arg0: &ValidatorSet): u64 {
B0:
0CopyLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2VecLen(58)
3CopyLoc[0](Arg0: &ValidatorSet)
4ImmBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
5VecLen(20)
6Sub
7MoveLoc[0](Arg0: &ValidatorSet)
8ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
9Call table_vec::length<Validator>(&TableVec<Validator>): u64
10Add
11Ret
}
public(friend) is_active_validator_by_sui_address(Arg0: &ValidatorSet, Arg1: address): bool {
L2: loc0: Option<u64>
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2MoveLoc[1](Arg1: address)
3Call find_validator(&vector<Validator>, address): Option<u64>
4StLoc[2](loc0: Option<u64>)
5ImmBorrowLoc[2](loc0: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7Ret
}
is_duplicate_with_active_validator(Arg0: &ValidatorSet, Arg1: &Validator): bool {
L2: loc0: u64
L3: loc1: bool
L4: loc2: bool
L5: loc3: u64
L6: loc4: u64
L7: loc5: u64
L8: loc6: &Validator
L9: loc7: &vector<Validator>
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2StLoc[9](loc7: &vector<Validator>)
3CopyLoc[9](loc7: &vector<Validator>)
4VecLen(58)
5StLoc[2](loc0: u64)
6LdU64(0)
7StLoc[6](loc4: u64)
8MoveLoc[2](loc0: u64)
9StLoc[7](loc5: u64)
B1:
10CopyLoc[6](loc4: u64)
11CopyLoc[7](loc5: u64)
12Lt
13BrFalse(49)
B2:
14CopyLoc[6](loc4: u64)
15StLoc[5](loc3: u64)
16CopyLoc[9](loc7: &vector<Validator>)
17MoveLoc[5](loc3: u64)
18VecImmBorrow(58)
19StLoc[8](loc6: &Validator)
20CopyLoc[8](loc6: &Validator)
21Call validator::sui_address(&Validator): address
22CopyLoc[1](Arg1: &Validator)
23Call validator::sui_address(&Validator): address
24Neq
25BrFalse(31)
B3:
26MoveLoc[8](loc6: &Validator)
27CopyLoc[1](Arg1: &Validator)
28Call validator::is_duplicate(&Validator, &Validator): bool
29StLoc[4](loc2: bool)
30Branch(35)
B4:
31MoveLoc[8](loc6: &Validator)
32Pop
33LdFalse
34StLoc[4](loc2: bool)
B5:
35MoveLoc[4](loc2: bool)
36BrFalse(44)
B6:
37MoveLoc[9](loc7: &vector<Validator>)
38Pop
39MoveLoc[1](Arg1: &Validator)
40Pop
41LdTrue
42StLoc[3](loc1: bool)
43Branch(55)
B7:
44MoveLoc[6](loc4: u64)
45LdU64(1)
46Add
47StLoc[6](loc4: u64)
48Branch(10)
B8:
49MoveLoc[9](loc7: &vector<Validator>)
50Pop
51MoveLoc[1](Arg1: &Validator)
52Pop
53LdFalse
54StLoc[3](loc1: bool)
B9:
55MoveLoc[3](loc1: bool)
56Ret
}
is_duplicate_with_pending_validator(Arg0: &ValidatorSet, Arg1: &Validator): bool {
L2: loc0: u64
L3: loc1: bool
L4: loc2: bool
L5: loc3: u64
L6: loc4: u64
L7: loc5: u64
L8: loc6: &Validator
B0:
0CopyLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
2Call table_vec::length<Validator>(&TableVec<Validator>): u64
3StLoc[2](loc0: u64)
4LdU64(0)
5StLoc[5](loc3: u64)
6MoveLoc[2](loc0: u64)
7StLoc[7](loc5: u64)
B1:
8CopyLoc[5](loc3: u64)
9CopyLoc[7](loc5: u64)
10Lt
11BrFalse(49)
B2:
12CopyLoc[5](loc3: u64)
13StLoc[6](loc4: u64)
14CopyLoc[0](Arg0: &ValidatorSet)
15ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
16MoveLoc[6](loc4: u64)
17Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
18StLoc[8](loc6: &Validator)
19CopyLoc[8](loc6: &Validator)
20Call validator::sui_address(&Validator): address
21CopyLoc[1](Arg1: &Validator)
22Call validator::sui_address(&Validator): address
23Neq
24BrFalse(31)
B3:
25Branch(26)
B4:
26MoveLoc[8](loc6: &Validator)
27CopyLoc[1](Arg1: &Validator)
28Call validator::is_duplicate(&Validator, &Validator): bool
29StLoc[4](loc2: bool)
30Branch(35)
B5:
31MoveLoc[8](loc6: &Validator)
32Pop
33LdFalse
34StLoc[4](loc2: bool)
B6:
35MoveLoc[4](loc2: bool)
36BrFalse(44)
B7:
37MoveLoc[0](Arg0: &ValidatorSet)
38Pop
39MoveLoc[1](Arg1: &Validator)
40Pop
41LdTrue
42StLoc[3](loc1: bool)
43Branch(55)
B8:
44MoveLoc[5](loc3: u64)
45LdU64(1)
46Add
47StLoc[5](loc3: u64)
48Branch(8)
B9:
49MoveLoc[0](Arg0: &ValidatorSet)
50Pop
51MoveLoc[1](Arg1: &Validator)
52Pop
53LdFalse
54StLoc[3](loc1: bool)
B10:
55MoveLoc[3](loc1: bool)
56Ret
}
get_candidate_or_active_validator_mut(Arg0: &mut ValidatorSet, Arg1: address): &mut Validator {
L2: loc0: &mut Validator
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
2CopyLoc[1](Arg1: address)
3Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
4BrFalse(10)
B1:
5MoveLoc[0](Arg0: &mut ValidatorSet)
6MoveLoc[1](Arg1: address)
7Call candidate_validator_mut(&mut ValidatorSet, address): &mut Validator
8StLoc[2](loc0: &mut Validator)
9Branch(14)
B2:
10MoveLoc[0](Arg0: &mut ValidatorSet)
11MoveLoc[1](Arg1: address)
12Call active_validator_mut(&mut ValidatorSet, address): &mut Validator
13StLoc[2](loc0: &mut Validator)
B3:
14MoveLoc[2](loc0: &mut Validator)
15Ret
}
find_validator(Arg0: &vector<Validator>, Arg1: address): Option<u64> {
L2: loc0: u64
L3: loc1: Option<u64>
L4: loc2: u64
L5: loc3: u64
L6: loc4: u64
L7: loc5: &vector<Validator>
B0:
0MoveLoc[0](Arg0: &vector<Validator>)
1StLoc[7](loc5: &vector<Validator>)
2CopyLoc[7](loc5: &vector<Validator>)
3VecLen(58)
4StLoc[2](loc0: u64)
5LdU64(0)
6StLoc[4](loc2: u64)
7MoveLoc[2](loc0: u64)
8StLoc[6](loc4: u64)
B1:
9CopyLoc[4](loc2: u64)
10CopyLoc[6](loc4: u64)
11Lt
12BrFalse(33)
B2:
13CopyLoc[4](loc2: u64)
14StLoc[5](loc3: u64)
15CopyLoc[7](loc5: &vector<Validator>)
16CopyLoc[5](loc3: u64)
17VecImmBorrow(58)
18Call validator::sui_address(&Validator): address
19CopyLoc[1](Arg1: address)
20Eq
21BrFalse(28)
B3:
22MoveLoc[7](loc5: &vector<Validator>)
23Pop
24MoveLoc[5](loc3: u64)
25Call option::some<u64>(u64): Option<u64>
26StLoc[3](loc1: Option<u64>)
27Branch(37)
B4:
28MoveLoc[4](loc2: u64)
29LdU64(1)
30Add
31StLoc[4](loc2: u64)
32Branch(9)
B5:
33MoveLoc[7](loc5: &vector<Validator>)
34Pop
35Call option::none<u64>(): Option<u64>
36StLoc[3](loc1: Option<u64>)
B6:
37MoveLoc[3](loc1: Option<u64>)
38Ret
}
find_validator_from_table_vec(Arg0: &TableVec<Validator>, Arg1: address): Option<u64> {
L2: loc0: u64
L3: loc1: Option<u64>
L4: loc2: u64
L5: loc3: u64
L6: loc4: u64
B0:
0CopyLoc[0](Arg0: &TableVec<Validator>)
1Call table_vec::length<Validator>(&TableVec<Validator>): u64
2StLoc[2](loc0: u64)
3LdU64(0)
4StLoc[4](loc2: u64)
5MoveLoc[2](loc0: u64)
6StLoc[6](loc4: u64)
B1:
7CopyLoc[4](loc2: u64)
8CopyLoc[6](loc4: u64)
9Lt
10BrFalse(32)
B2:
11CopyLoc[4](loc2: u64)
12StLoc[5](loc3: u64)
13CopyLoc[0](Arg0: &TableVec<Validator>)
14CopyLoc[5](loc3: u64)
15Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
16Call validator::sui_address(&Validator): address
17CopyLoc[1](Arg1: address)
18Eq
19BrFalse(27)
B3:
20Branch(21)
B4:
21MoveLoc[0](Arg0: &TableVec<Validator>)
22Pop
23MoveLoc[5](loc3: u64)
24Call option::some<u64>(u64): Option<u64>
25StLoc[3](loc1: Option<u64>)
26Branch(36)
B5:
27MoveLoc[4](loc2: u64)
28LdU64(1)
29Add
30StLoc[4](loc2: u64)
31Branch(7)
B6:
32MoveLoc[0](Arg0: &TableVec<Validator>)
33Pop
34Call option::none<u64>(): Option<u64>
35StLoc[3](loc1: Option<u64>)
B7:
36MoveLoc[3](loc1: Option<u64>)
37Ret
}
get_validator_indices(Arg0: &vector<Validator>, Arg1: &vector<address>): vector<u64> {
L2: loc0: u64
L3: loc1: u64
L4: loc2: &mut vector<u64>
L5: loc3: &address
L6: loc4: &address
L7: loc5: u64
L8: loc6: u64
L9: loc7: Option<u64>
L10: loc8: vector<u64>
L11: loc9: u64
L12: loc10: &vector<address>
L13: loc11: &vector<address>
B0:
0MoveLoc[1](Arg1: &vector<address>)
1StLoc[12](loc10: &vector<address>)
2LdConst[21](vector<u64>: 00)
3StLoc[10](loc8: vector<u64>)
4MoveLoc[12](loc10: &vector<address>)
5StLoc[13](loc11: &vector<address>)
6CopyLoc[13](loc11: &vector<address>)
7VecLen(26)
8StLoc[2](loc0: u64)
9LdU64(0)
10StLoc[8](loc6: u64)
11MoveLoc[2](loc0: u64)
12StLoc[11](loc9: u64)
B1:
13CopyLoc[8](loc6: u64)
14CopyLoc[11](loc9: u64)
15Lt
16BrFalse(57)
B2:
17CopyLoc[8](loc6: u64)
18StLoc[7](loc5: u64)
19CopyLoc[13](loc11: &vector<address>)
20MoveLoc[7](loc5: u64)
21VecImmBorrow(26)
22StLoc[6](loc4: &address)
23MutBorrowLoc[10](loc8: vector<u64>)
24StLoc[4](loc2: &mut vector<u64>)
25MoveLoc[6](loc4: &address)
26StLoc[5](loc3: &address)
27CopyLoc[0](Arg0: &vector<Validator>)
28MoveLoc[5](loc3: &address)
29ReadRef
30Call find_validator(&vector<Validator>, address): Option<u64>
31StLoc[9](loc7: Option<u64>)
32ImmBorrowLoc[9](loc7: Option<u64>)
33Call option::is_some<u64>(&Option<u64>): bool
34BrFalse(36)
B3:
35Branch(46)
B4:
36MoveLoc[0](Arg0: &vector<Validator>)
37Pop
38MoveLoc[13](loc11: &vector<address>)
39Pop
40MoveLoc[4](loc2: &mut vector<u64>)
41Pop
42MoveLoc[9](loc7: Option<u64>)
43Call option::destroy_none<u64>(Option<u64>)
44LdConst[4](u64: 4)
45Abort
B5:
46MoveLoc[9](loc7: Option<u64>)
47Call option::destroy_some<u64>(Option<u64>): u64
48StLoc[3](loc1: u64)
49MoveLoc[4](loc2: &mut vector<u64>)
50MoveLoc[3](loc1: u64)
51VecPushBack(20)
52MoveLoc[8](loc6: u64)
53LdU64(1)
54Add
55StLoc[8](loc6: u64)
56Branch(13)
B6:
57MoveLoc[0](Arg0: &vector<Validator>)
58Pop
59MoveLoc[13](loc11: &vector<address>)
60Pop
61MoveLoc[10](loc8: vector<u64>)
62Ret
}
public(friend) any_validator(Arg0: &mut ValidatorSet, Arg1: address): &Validator {
L2: loc0: Option<u64>
L3: loc1: Option<u64>
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2CopyLoc[1](Arg1: address)
3Call find_validator(&vector<Validator>, address): Option<u64>
4StLoc[2](loc0: Option<u64>)
5ImmBorrowLoc[2](loc0: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7BrFalse(14)
B1:
8MoveLoc[0](Arg0: &mut ValidatorSet)
9ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
10MoveLoc[2](loc0: Option<u64>)
11Call option::destroy_some<u64>(Option<u64>): u64
12VecImmBorrow(58)
13Ret
B2:
14CopyLoc[0](Arg0: &mut ValidatorSet)
15ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
16CopyLoc[1](Arg1: address)
17Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
18StLoc[3](loc1: Option<u64>)
19ImmBorrowLoc[3](loc1: Option<u64>)
20Call option::is_some<u64>(&Option<u64>): bool
21BrFalse(28)
B3:
22MoveLoc[0](Arg0: &mut ValidatorSet)
23ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
24MoveLoc[3](loc1: Option<u64>)
25Call option::destroy_some<u64>(Option<u64>): u64
26Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
27Ret
B4:
28MoveLoc[0](Arg0: &mut ValidatorSet)
29MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
30MoveLoc[1](Arg1: address)
31Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
32Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
33FreezeRef
34Ret
}
public(friend) any_validator_mut(Arg0: &mut ValidatorSet, Arg1: address): &mut Validator {
L2: loc0: Option<u64>
L3: loc1: Option<u64>
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2CopyLoc[1](Arg1: address)
3Call find_validator(&vector<Validator>, address): Option<u64>
4StLoc[2](loc0: Option<u64>)
5ImmBorrowLoc[2](loc0: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7BrFalse(14)
B1:
8MoveLoc[0](Arg0: &mut ValidatorSet)
9MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
10MoveLoc[2](loc0: Option<u64>)
11Call option::destroy_some<u64>(Option<u64>): u64
12VecMutBorrow(58)
13Ret
B2:
14CopyLoc[0](Arg0: &mut ValidatorSet)
15ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
16CopyLoc[1](Arg1: address)
17Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
18StLoc[3](loc1: Option<u64>)
19ImmBorrowLoc[3](loc1: Option<u64>)
20Call option::is_some<u64>(&Option<u64>): bool
21BrFalse(28)
B3:
22MoveLoc[0](Arg0: &mut ValidatorSet)
23MutBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
24MoveLoc[3](loc1: Option<u64>)
25Call option::destroy_some<u64>(Option<u64>): u64
26Call table_vec::borrow_mut<Validator>(&mut TableVec<Validator>, u64): &mut Validator
27Ret
B4:
28MoveLoc[0](Arg0: &mut ValidatorSet)
29MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
30MoveLoc[1](Arg1: address)
31Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
32Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
33Ret
}
public(friend) active_validator(Arg0: &ValidatorSet, Arg1: address): &Validator {
L2: loc0: u64
L3: loc1: Option<u64>
B0:
0CopyLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2MoveLoc[1](Arg1: address)
3Call find_validator(&vector<Validator>, address): Option<u64>
4StLoc[3](loc1: Option<u64>)
5ImmBorrowLoc[3](loc1: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &ValidatorSet)
10Pop
11MoveLoc[3](loc1: Option<u64>)
12Call option::destroy_none<u64>(Option<u64>)
13LdConst[4](u64: 4)
14Abort
B3:
15MoveLoc[3](loc1: Option<u64>)
16Call option::destroy_some<u64>(Option<u64>): u64
17StLoc[2](loc0: u64)
18MoveLoc[0](Arg0: &ValidatorSet)
19ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
20MoveLoc[2](loc0: u64)
21VecImmBorrow(58)
22Ret
}
public(friend) active_validator_mut(Arg0: &mut ValidatorSet, Arg1: address): &mut Validator {
L2: loc0: u64
L3: loc1: Option<u64>
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2MoveLoc[1](Arg1: address)
3Call find_validator(&vector<Validator>, address): Option<u64>
4StLoc[3](loc1: Option<u64>)
5ImmBorrowLoc[3](loc1: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &mut ValidatorSet)
10Pop
11MoveLoc[3](loc1: Option<u64>)
12Call option::destroy_none<u64>(Option<u64>)
13LdConst[4](u64: 4)
14Abort
B3:
15MoveLoc[3](loc1: Option<u64>)
16Call option::destroy_some<u64>(Option<u64>): u64
17StLoc[2](loc0: u64)
18MoveLoc[0](Arg0: &mut ValidatorSet)
19MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
20MoveLoc[2](loc0: u64)
21VecMutBorrow(58)
22Ret
}
public(friend) pending_validator(Arg0: &ValidatorSet, Arg1: address): &Validator {
L2: loc0: u64
L3: loc1: Option<u64>
B0:
0CopyLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
2MoveLoc[1](Arg1: address)
3Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
4StLoc[3](loc1: Option<u64>)
5ImmBorrowLoc[3](loc1: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &ValidatorSet)
10Pop
11MoveLoc[3](loc1: Option<u64>)
12Call option::destroy_none<u64>(Option<u64>)
13LdConst[11](u64: 12)
14Abort
B3:
15MoveLoc[3](loc1: Option<u64>)
16Call option::destroy_some<u64>(Option<u64>): u64
17StLoc[2](loc0: u64)
18MoveLoc[0](Arg0: &ValidatorSet)
19ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
20MoveLoc[2](loc0: u64)
21Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
22Ret
}
public(friend) pending_validator_mut(Arg0: &mut ValidatorSet, Arg1: address): &mut Validator {
L2: loc0: u64
L3: loc1: Option<u64>
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
2MoveLoc[1](Arg1: address)
3Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
4StLoc[3](loc1: Option<u64>)
5ImmBorrowLoc[3](loc1: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &mut ValidatorSet)
10Pop
11MoveLoc[3](loc1: Option<u64>)
12Call option::destroy_none<u64>(Option<u64>)
13LdConst[11](u64: 12)
14Abort
B3:
15MoveLoc[3](loc1: Option<u64>)
16Call option::destroy_some<u64>(Option<u64>): u64
17StLoc[2](loc0: u64)
18MoveLoc[0](Arg0: &mut ValidatorSet)
19MutBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
20MoveLoc[2](loc0: u64)
21Call table_vec::borrow_mut<Validator>(&mut TableVec<Validator>, u64): &mut Validator
22Ret
}
public(friend) candidate_validator(Arg0: &mut ValidatorSet, Arg1: address): &Validator {
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
2CopyLoc[1](Arg1: address)
3Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &mut ValidatorSet)
7Pop
8LdConst[8](u64: 8)
9Abort
B3:
10MoveLoc[0](Arg0: &mut ValidatorSet)
11MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
12MoveLoc[1](Arg1: address)
13Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
14Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
15FreezeRef
16Ret
}
public(friend) candidate_validator_mut(Arg0: &mut ValidatorSet, Arg1: address): &mut Validator {
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
2CopyLoc[1](Arg1: address)
3Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &mut ValidatorSet)
7Pop
8LdConst[8](u64: 8)
9Abort
B3:
10MoveLoc[0](Arg0: &mut ValidatorSet)
11MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
12MoveLoc[1](Arg1: address)
13Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
14Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
15Ret
}
get_validator_ref(Arg0: &vector<Validator>, Arg1: address): &Validator {
L2: loc0: u64
L3: loc1: Option<u64>
B0:
0CopyLoc[0](Arg0: &vector<Validator>)
1MoveLoc[1](Arg1: address)
2Call find_validator(&vector<Validator>, address): Option<u64>
3StLoc[3](loc1: Option<u64>)
4ImmBorrowLoc[3](loc1: Option<u64>)
5Call option::is_some<u64>(&Option<u64>): bool
6BrFalse(8)
B1:
7Branch(14)
B2:
8MoveLoc[0](Arg0: &vector<Validator>)
9Pop
10MoveLoc[3](loc1: Option<u64>)
11Call option::destroy_none<u64>(Option<u64>)
12LdConst[4](u64: 4)
13Abort
B3:
14MoveLoc[3](loc1: Option<u64>)
15Call option::destroy_some<u64>(Option<u64>): u64
16StLoc[2](loc0: u64)
17MoveLoc[0](Arg0: &vector<Validator>)
18MoveLoc[2](loc0: u64)
19VecImmBorrow(58)
20Ret
}
public(friend) get_active_or_pending_or_candidate_validator_ref(Arg0: &mut ValidatorSet, Arg1: address, Arg2: u8): &Validator {
L3: loc0: bool
L4: loc1: bool
L5: loc2: u64
L6: loc3: u64
L7: loc4: Option<u64>
L8: loc5: Option<u64>
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2CopyLoc[1](Arg1: address)
3Call find_validator(&vector<Validator>, address): Option<u64>
4StLoc[7](loc4: Option<u64>)
5ImmBorrowLoc[7](loc4: Option<u64>)
6Call option::is_some<u64>(&Option<u64>): bool
7BrFalse(11)
B1:
8LdTrue
9StLoc[3](loc0: bool)
10Branch(15)
B2:
11CopyLoc[2](Arg2: u8)
12LdConst[16](u8: 1)
13Eq
14StLoc[3](loc0: bool)
B3:
15MoveLoc[3](loc0: bool)
16BrFalse(25)
B4:
17MutBorrowLoc[7](loc4: Option<u64>)
18Call option::extract<u64>(&mut Option<u64>): u64
19StLoc[5](loc2: u64)
20MoveLoc[0](Arg0: &mut ValidatorSet)
21ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
22MoveLoc[5](loc2: u64)
23VecImmBorrow(58)
24Ret
B5:
25CopyLoc[0](Arg0: &mut ValidatorSet)
26ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
27CopyLoc[1](Arg1: address)
28Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
29StLoc[8](loc5: Option<u64>)
30ImmBorrowLoc[8](loc5: Option<u64>)
31Call option::is_some<u64>(&Option<u64>): bool
32BrFalse(36)
B6:
33LdTrue
34StLoc[4](loc1: bool)
35Branch(40)
B7:
36MoveLoc[2](Arg2: u8)
37LdConst[17](u8: 2)
38Eq
39StLoc[4](loc1: bool)
B8:
40MoveLoc[4](loc1: bool)
41BrFalse(50)
B9:
42MutBorrowLoc[8](loc5: Option<u64>)
43Call option::extract<u64>(&mut Option<u64>): u64
44StLoc[6](loc3: u64)
45MoveLoc[0](Arg0: &mut ValidatorSet)
46ImmBorrowField[2](ValidatorSet.pending_active_validators: TableVec<Validator>)
47MoveLoc[6](loc3: u64)
48Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
49Ret
B10:
50MoveLoc[0](Arg0: &mut ValidatorSet)
51MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
52MoveLoc[1](Arg1: address)
53Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
54Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
55FreezeRef
56Ret
}
public(friend) verify_cap(Arg0: &mut ValidatorSet, Arg1: &UnverifiedValidatorOperationCap, Arg2: u8): ValidatorOperationCap {
L3: loc0: &u8
L4: loc1: u8
L5: loc2: &u8
L6: loc3: &Validator
L7: loc4: u8
L8: loc5: &u8
L9: loc6: &Validator
L10: loc7: &Validator
L11: loc8: ID
L12: loc9: &ID
L13: loc10: u8
L14: loc11: &u8
L15: loc12: u8
L16: loc13: Option<u64>
L17: loc14: address
B0:
0CopyLoc[1](Arg1: &UnverifiedValidatorOperationCap)
1Call validator_cap::unverified_operation_cap_address(&UnverifiedValidatorOperationCap): &address
2ReadRef
3StLoc[17](loc14: address)
4MoveLoc[2](Arg2: u8)
5StLoc[15](loc12: u8)
6ImmBorrowLoc[15](loc12: u8)
7StLoc[14](loc11: &u8)
8CopyLoc[14](loc11: &u8)
9StLoc[3](loc0: &u8)
10LdConst[16](u8: 1)
11StLoc[13](loc10: u8)
12MoveLoc[3](loc0: &u8)
13ImmBorrowLoc[13](loc10: u8)
14Eq
15BrFalse(24)
B1:
16MoveLoc[14](loc11: &u8)
17Pop
18MoveLoc[0](Arg0: &mut ValidatorSet)
19FreezeRef
20MoveLoc[17](loc14: address)
21Call active_validator(&ValidatorSet, address): &Validator
22StLoc[10](loc7: &Validator)
23Branch(78)
B2:
24CopyLoc[14](loc11: &u8)
25StLoc[5](loc2: &u8)
26LdConst[17](u8: 2)
27StLoc[4](loc1: u8)
28MoveLoc[5](loc2: &u8)
29ImmBorrowLoc[4](loc1: u8)
30Eq
31BrFalse(57)
B3:
32MoveLoc[14](loc11: &u8)
33Pop
34CopyLoc[0](Arg0: &mut ValidatorSet)
35ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
36CopyLoc[17](loc14: address)
37Call find_validator(&vector<Validator>, address): Option<u64>
38StLoc[16](loc13: Option<u64>)
39ImmBorrowLoc[16](loc13: Option<u64>)
40Call option::is_some<u64>(&Option<u64>): bool
41BrFalse(49)
B4:
42MoveLoc[0](Arg0: &mut ValidatorSet)
43ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
44MoveLoc[16](loc13: Option<u64>)
45Call option::destroy_some<u64>(Option<u64>): u64
46VecImmBorrow(58)
47StLoc[6](loc3: &Validator)
48Branch(54)
B5:
49MoveLoc[0](Arg0: &mut ValidatorSet)
50FreezeRef
51MoveLoc[17](loc14: address)
52Call pending_validator(&ValidatorSet, address): &Validator
53StLoc[6](loc3: &Validator)
B6:
54MoveLoc[6](loc3: &Validator)
55StLoc[9](loc6: &Validator)
56Branch(76)
B7:
57MoveLoc[14](loc11: &u8)
58StLoc[8](loc5: &u8)
59LdConst[18](u8: 3)
60StLoc[7](loc4: u8)
61MoveLoc[8](loc5: &u8)
62ImmBorrowLoc[7](loc4: u8)
63Eq
64BrFalse(66)
B8:
65Branch(72)
B9:
66MoveLoc[0](Arg0: &mut ValidatorSet)
67Pop
68MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
69Pop
70LdConst[14](u64: 14)
71Abort
B10:
72MoveLoc[0](Arg0: &mut ValidatorSet)
73MoveLoc[17](loc14: address)
74Call any_validator(&mut ValidatorSet, address): &Validator
75StLoc[9](loc6: &Validator)
B11:
76MoveLoc[9](loc6: &Validator)
77StLoc[10](loc7: &Validator)
B12:
78MoveLoc[10](loc7: &Validator)
79Call validator::operation_cap_id(&Validator): &ID
80StLoc[12](loc9: &ID)
81CopyLoc[1](Arg1: &UnverifiedValidatorOperationCap)
82Call object::id<UnverifiedValidatorOperationCap>(&UnverifiedValidatorOperationCap): ID
83StLoc[11](loc8: ID)
84MoveLoc[12](loc9: &ID)
85ImmBorrowLoc[11](loc8: ID)
86Eq
87BrFalse(89)
B13:
88Branch(93)
B14:
89MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
90Pop
91LdConst[13](u64: 101)
92Abort
B15:
93MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
94Call validator_cap::into_verified(&UnverifiedValidatorOperationCap): ValidatorOperationCap
95Ret
}
process_pending_removals(Arg0: &mut ValidatorSet, Arg1: &mut VecMap<address, VecSet<address>>, Arg2: &mut TxContext) {
L3: loc0: u64
L4: loc1: bool
L5: loc2: &u64
L6: loc3: &u64
L7: loc4: u64
L8: loc5: u64
L9: loc6: u64
L10: loc7: u64
L11: loc8: u64
L12: loc9: u64
L13: loc10: &mut vector<u64>
L14: loc11: Validator
B0:
0CopyLoc[0](Arg0: &mut ValidatorSet)
1MutBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
2StLoc[13](loc10: &mut vector<u64>)
3CopyLoc[13](loc10: &mut vector<u64>)
4FreezeRef
5VecLen(20)
6StLoc[11](loc8: u64)
7CopyLoc[11](loc8: u64)
8LdU64(2)
9Lt
10BrFalse(14)
B1:
11MoveLoc[13](loc10: &mut vector<u64>)
12Pop
13Branch(69)
B2:
14LdU64(1)
15StLoc[7](loc4: u64)
B3:
16CopyLoc[7](loc4: u64)
17CopyLoc[11](loc8: u64)
18Lt
19BrFalse(67)
B4:
20CopyLoc[7](loc4: u64)
21StLoc[10](loc7: u64)
22Branch(23)
B5:
23CopyLoc[10](loc7: u64)
24LdU64(0)
25Gt
26BrFalse(47)
B6:
27CopyLoc[13](loc10: &mut vector<u64>)
28FreezeRef
29CopyLoc[10](loc7: u64)
30LdU64(1)
31Sub
32VecImmBorrow(20)
33StLoc[5](loc2: &u64)
34CopyLoc[13](loc10: &mut vector<u64>)
35FreezeRef
36CopyLoc[10](loc7: u64)
37VecImmBorrow(20)
38StLoc[6](loc3: &u64)
39MoveLoc[5](loc2: &u64)
40ReadRef
41MoveLoc[6](loc3: &u64)
42ReadRef
43Le
44Not
45StLoc[4](loc1: bool)
46Branch(49)
B7:
47LdFalse
48StLoc[4](loc1: bool)
B8:
49MoveLoc[4](loc1: bool)
50BrFalse(62)
B9:
51CopyLoc[13](loc10: &mut vector<u64>)
52CopyLoc[10](loc7: u64)
53CopyLoc[10](loc7: u64)
54LdU64(1)
55Sub
56VecSwap(20)
57MoveLoc[10](loc7: u64)
58LdU64(1)
59Sub
60StLoc[10](loc7: u64)
61Branch(23)
B10:
62MoveLoc[7](loc4: u64)
63LdU64(1)
64Add
65StLoc[7](loc4: u64)
66Branch(16)
B11:
67MoveLoc[13](loc10: &mut vector<u64>)
68Pop
B12:
69CopyLoc[0](Arg0: &mut ValidatorSet)
70ImmBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
71VecLen(20)
72StLoc[3](loc0: u64)
73LdU64(0)
74StLoc[8](loc5: u64)
75MoveLoc[3](loc0: u64)
76StLoc[12](loc9: u64)
B13:
77CopyLoc[8](loc5: u64)
78CopyLoc[12](loc9: u64)
79Lt
80BrFalse(104)
B14:
81CopyLoc[8](loc5: u64)
82Pop
83CopyLoc[0](Arg0: &mut ValidatorSet)
84MutBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
85VecPopBack(20)
86StLoc[9](loc6: u64)
87CopyLoc[0](Arg0: &mut ValidatorSet)
88MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
89MoveLoc[9](loc6: u64)
90Call vector::remove<Validator>(&mut vector<Validator>, u64): Validator
91StLoc[14](loc11: Validator)
92CopyLoc[0](Arg0: &mut ValidatorSet)
93MoveLoc[14](loc11: Validator)
94CopyLoc[1](Arg1: &mut VecMap<address, VecSet<address>>)
95LdTrue
96CopyLoc[2](Arg2: &mut TxContext)
97Call process_validator_departure(&mut ValidatorSet, Validator, &mut VecMap<address, VecSet<address>>, bool, &mut TxContext): u64
98Pop
99MoveLoc[8](loc5: u64)
100LdU64(1)
101Add
102StLoc[8](loc5: u64)
103Branch(77)
B15:
104MoveLoc[1](Arg1: &mut VecMap<address, VecSet<address>>)
105Pop
106MoveLoc[0](Arg0: &mut ValidatorSet)
107Pop
108MoveLoc[2](Arg2: &mut TxContext)
109Pop
110Ret
}
process_validator_departure(Arg0: &mut ValidatorSet, Arg1: Validator, Arg2: &mut VecMap<address, VecSet<address>>, Arg3: bool, Arg4: &mut TxContext): u64 {
L5: loc0: u64
L6: loc1: u64
L7: loc2: address
L8: loc3: ID
B0:
0CopyLoc[4](Arg4: &mut TxContext)
1FreezeRef
2Call tx_context::epoch(&TxContext): u64
3LdU64(1)
4Add
5StLoc[5](loc0: u64)
6ImmBorrowLoc[1](Arg1: Validator)
7Call validator::sui_address(&Validator): address
8StLoc[7](loc2: address)
9ImmBorrowLoc[1](Arg1: Validator)
10Call validator::staking_pool_id(&Validator): ID
11StLoc[8](loc3: ID)
12CopyLoc[0](Arg0: &mut ValidatorSet)
13MutBorrowField[3](ValidatorSet.staking_pool_mappings: Table<ID, address>)
14CopyLoc[8](loc3: ID)
15Call table::remove<ID, address>(&mut Table<ID, address>, ID): address
16Pop
17CopyLoc[0](Arg0: &mut ValidatorSet)
18ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
19ImmBorrowLoc[7](loc2: address)
20Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
21BrFalse(28)
B1:
22CopyLoc[0](Arg0: &mut ValidatorSet)
23MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
24ImmBorrowLoc[7](loc2: address)
25Call vec_map::remove<address, u64>(&mut VecMap<address, u64>, &address): address * u64
26Pop
27Pop
B2:
28MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
29CopyLoc[7](loc2: address)
30Call clean_report_records_leaving_validator(&mut VecMap<address, VecSet<address>>, address)
31CopyLoc[5](loc0: u64)
32MoveLoc[7](loc2: address)
33ImmBorrowLoc[1](Arg1: Validator)
34Call validator::staking_pool_id(&Validator): ID
35MoveLoc[3](Arg3: bool)
36Pack[4](ValidatorLeaveEvent)
37Call event::emit<ValidatorLeaveEvent>(ValidatorLeaveEvent)
38ImmBorrowLoc[1](Arg1: Validator)
39Call validator::total_stake(&Validator): u64
40StLoc[6](loc1: u64)
41MutBorrowLoc[1](Arg1: Validator)
42MoveLoc[5](loc0: u64)
43Call validator::deactivate(&mut Validator, u64)
44MoveLoc[0](Arg0: &mut ValidatorSet)
45MutBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
46MoveLoc[8](loc3: ID)
47MoveLoc[1](Arg1: Validator)
48MoveLoc[4](Arg4: &mut TxContext)
49Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
50Call table::add<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID, ValidatorWrapper)
51MoveLoc[6](loc1: u64)
52Ret
}
clean_report_records_leaving_validator(Arg0: &mut VecMap<address, VecSet<address>>, Arg1: address) {
L2: loc0: u64
L3: loc1: u64
L4: loc2: u64
L5: loc3: &address
L6: loc4: vector<address>
L7: loc5: &mut VecSet<address>
L8: loc6: u64
B0:
0CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
1FreezeRef
2ImmBorrowLoc[1](Arg1: address)
3Call vec_map::contains<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): bool
4BrFalse(10)
B1:
5CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
6ImmBorrowLoc[1](Arg1: address)
7Call vec_map::remove<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): address * VecSet<address>
8Pop
9Pop
B2:
10CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
11FreezeRef
12Call vec_map::keys<address, VecSet<address>>(&VecMap<address, VecSet<address>>): vector<address>
13StLoc[6](loc4: vector<address>)
14ImmBorrowLoc[6](loc4: vector<address>)
15VecLen(26)
16StLoc[2](loc0: u64)
17LdU64(0)
18StLoc[3](loc1: u64)
19MoveLoc[2](loc0: u64)
20StLoc[8](loc6: u64)
B3:
21CopyLoc[3](loc1: u64)
22CopyLoc[8](loc6: u64)
23Lt
24BrFalse(65)
B4:
25CopyLoc[3](loc1: u64)
26StLoc[4](loc2: u64)
27ImmBorrowLoc[6](loc4: vector<address>)
28MoveLoc[4](loc2: u64)
29VecImmBorrow(26)
30StLoc[5](loc3: &address)
31CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
32CopyLoc[5](loc3: &address)
33Call vec_map::get_mut<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): &mut VecSet<address>
34StLoc[7](loc5: &mut VecSet<address>)
35CopyLoc[7](loc5: &mut VecSet<address>)
36FreezeRef
37ImmBorrowLoc[1](Arg1: address)
38Call vec_set::contains<address>(&VecSet<address>, &address): bool
39BrFalse(56)
B5:
40CopyLoc[7](loc5: &mut VecSet<address>)
41ImmBorrowLoc[1](Arg1: address)
42Call vec_set::remove<address>(&mut VecSet<address>, &address)
43MoveLoc[7](loc5: &mut VecSet<address>)
44FreezeRef
45Call vec_set::is_empty<address>(&VecSet<address>): bool
46BrFalse(53)
B6:
47CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
48MoveLoc[5](loc3: &address)
49Call vec_map::remove<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): address * VecSet<address>
50Pop
51Pop
52Branch(60)
B7:
53MoveLoc[5](loc3: &address)
54Pop
55Branch(60)
B8:
56MoveLoc[7](loc5: &mut VecSet<address>)
57Pop
58MoveLoc[5](loc3: &address)
59Pop
B9:
60MoveLoc[3](loc1: u64)
61LdU64(1)
62Add
63StLoc[3](loc1: u64)
64Branch(21)
B10:
65MoveLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
66Pop
67Ret
}
public(friend) calculate_total_stakes(Arg0: &vector<Validator>): u64 {
L1: loc0: u64
L2: loc1: u64
L3: loc2: u64
L4: loc3: u64
L5: loc4: u64
L6: loc5: &vector<Validator>
L7: loc6: &Validator
B0:
0LdU64(0)
1StLoc[4](loc3: u64)
2MoveLoc[0](Arg0: &vector<Validator>)
3StLoc[6](loc5: &vector<Validator>)
4CopyLoc[6](loc5: &vector<Validator>)
5VecLen(58)
6StLoc[1](loc0: u64)
7LdU64(0)
8StLoc[2](loc1: u64)
9MoveLoc[1](loc0: u64)
10StLoc[5](loc4: u64)
B1:
11CopyLoc[2](loc1: u64)
12CopyLoc[5](loc4: u64)
13Lt
14BrFalse(31)
B2:
15CopyLoc[2](loc1: u64)
16StLoc[3](loc2: u64)
17CopyLoc[6](loc5: &vector<Validator>)
18MoveLoc[3](loc2: u64)
19VecImmBorrow(58)
20StLoc[7](loc6: &Validator)
21MoveLoc[4](loc3: u64)
22MoveLoc[7](loc6: &Validator)
23Call validator::total_stake(&Validator): u64
24Add
25StLoc[4](loc3: u64)
26MoveLoc[2](loc1: u64)
27LdU64(1)
28Add
29StLoc[2](loc1: u64)
30Branch(11)
B3:
31MoveLoc[6](loc5: &vector<Validator>)
32Pop
33MoveLoc[4](loc3: u64)
34Ret
}
compute_reward_adjustments(Arg0: vector<u64>, Arg1: u64, Arg2: &vector<u64>, Arg3: &vector<u64>): u64 * VecMap<u64, u64> * u64 * VecMap<u64, u64> {
L4: loc0: u64
L5: loc1: u64
L6: loc2: VecMap<u64, u64>
L7: loc3: VecMap<u64, u64>
L8: loc4: u64
L9: loc5: u64
L10: loc6: u64
L11: loc7: u64
L12: loc8: u64
L13: loc9: vector<u64>
L14: loc10: u64
B0:
0LdU64(0)
1StLoc[11](loc7: u64)
2Call vec_map::empty<u64, u64>(): VecMap<u64, u64>
3StLoc[6](loc2: VecMap<u64, u64>)
4LdU64(0)
5StLoc[12](loc8: u64)
6Call vec_map::empty<u64, u64>(): VecMap<u64, u64>
7StLoc[7](loc3: VecMap<u64, u64>)
8MoveLoc[0](Arg0: vector<u64>)
9StLoc[13](loc9: vector<u64>)
10ImmBorrowLoc[13](loc9: vector<u64>)
11VecLen(20)
12StLoc[4](loc0: u64)
13LdU64(0)
14StLoc[5](loc1: u64)
15MoveLoc[4](loc0: u64)
16StLoc[9](loc5: u64)
B1:
17CopyLoc[5](loc1: u64)
18CopyLoc[9](loc5: u64)
19Lt
20BrFalse(73)
B2:
21CopyLoc[5](loc1: u64)
22Pop
23MutBorrowLoc[13](loc9: vector<u64>)
24VecPopBack(20)
25StLoc[14](loc10: u64)
26CopyLoc[2](Arg2: &vector<u64>)
27CopyLoc[14](loc10: u64)
28VecImmBorrow(20)
29ReadRef
30CastU128
31CopyLoc[1](Arg1: u64)
32CastU128
33Mul
34LdConst[19](u64: 10000)
35CastU128
36Div
37CastU64
38StLoc[8](loc4: u64)
39MutBorrowLoc[6](loc2: VecMap<u64, u64>)
40CopyLoc[14](loc10: u64)
41CopyLoc[8](loc4: u64)
42Call vec_map::insert<u64, u64>(&mut VecMap<u64, u64>, u64, u64)
43MoveLoc[11](loc7: u64)
44MoveLoc[8](loc4: u64)
45Add
46StLoc[11](loc7: u64)
47CopyLoc[3](Arg3: &vector<u64>)
48CopyLoc[14](loc10: u64)
49VecImmBorrow(20)
50ReadRef
51CastU128
52CopyLoc[1](Arg1: u64)
53CastU128
54Mul
55LdConst[19](u64: 10000)
56CastU128
57Div
58CastU64
59StLoc[10](loc6: u64)
60MutBorrowLoc[7](loc3: VecMap<u64, u64>)
61MoveLoc[14](loc10: u64)
62CopyLoc[10](loc6: u64)
63Call vec_map::insert<u64, u64>(&mut VecMap<u64, u64>, u64, u64)
64MoveLoc[12](loc8: u64)
65MoveLoc[10](loc6: u64)
66Add
67StLoc[12](loc8: u64)
68MoveLoc[5](loc1: u64)
69LdU64(1)
70Add
71StLoc[5](loc1: u64)
72Branch(17)
B3:
73MoveLoc[3](Arg3: &vector<u64>)
74Pop
75MoveLoc[2](Arg2: &vector<u64>)
76Pop
77MoveLoc[13](loc9: vector<u64>)
78VecUnpack(20, 0)
79MoveLoc[11](loc7: u64)
80MoveLoc[6](loc2: VecMap<u64, u64>)
81MoveLoc[12](loc8: u64)
82MoveLoc[7](loc3: VecMap<u64, u64>)
83Ret
}
compute_slashed_validators(Arg0: &ValidatorSet, Arg1: VecMap<address, VecSet<address>>): vector<address> {
L2: loc0: vector<address>
L3: loc1: &vector<Validator>
L4: loc2: VecSet<address>
L5: loc3: vector<address>
L6: loc4: address
B0:
0LdConst[22](vector<address>: 00)
1StLoc[5](loc3: vector<address>)
B1:
2ImmBorrowLoc[1](Arg1: VecMap<address, VecSet<address>>)
3Call vec_map::is_empty<address, VecSet<address>>(&VecMap<address, VecSet<address>>): bool
4Not
5BrFalse(36)
B2:
6Branch(7)
B3:
7MutBorrowLoc[1](Arg1: VecMap<address, VecSet<address>>)
8Call vec_map::pop<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>): address * VecSet<address>
9StLoc[4](loc2: VecSet<address>)
10StLoc[6](loc4: address)
11CopyLoc[0](Arg0: &ValidatorSet)
12CopyLoc[6](loc4: address)
13Call is_active_validator_by_sui_address(&ValidatorSet, address): bool
14BrFalse(16)
B4:
15Branch(20)
B5:
16MoveLoc[0](Arg0: &ValidatorSet)
17Pop
18LdConst[0](u64: 0)
19Abort
B6:
20CopyLoc[0](Arg0: &ValidatorSet)
21ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
22StLoc[3](loc1: &vector<Validator>)
23MoveLoc[4](loc2: VecSet<address>)
24Call vec_set::into_keys<address>(VecSet<address>): vector<address>
25StLoc[2](loc0: vector<address>)
26MoveLoc[3](loc1: &vector<Validator>)
27ImmBorrowLoc[2](loc0: vector<address>)
28Call sum_voting_power_by_addresses(&vector<Validator>, &vector<address>): u64
29Call voting_power::quorum_threshold(): u64
30Ge
31BrFalse(2)
B7:
32MutBorrowLoc[5](loc3: vector<address>)
33MoveLoc[6](loc4: address)
34VecPushBack(26)
35Branch(2)
B8:
36MoveLoc[0](Arg0: &ValidatorSet)
37Pop
38MoveLoc[5](loc3: vector<address>)
39Ret
}
compute_unadjusted_reward_distribution(Arg0: &vector<Validator>, Arg1: u64, Arg2: u64, Arg3: u64): vector<u64> * vector<u64> {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
L8: loc4: u64
L9: loc5: vector<u64>
L10: loc6: u64
L11: loc7: vector<u64>
L12: loc8: u64
L13: loc9: &vector<Validator>
B0:
0LdConst[21](vector<u64>: 00)
1StLoc[9](loc5: vector<u64>)
2LdConst[21](vector<u64>: 00)
3StLoc[11](loc7: vector<u64>)
4CopyLoc[0](Arg0: &vector<Validator>)
5VecLen(58)
6StLoc[7](loc3: u64)
7MoveLoc[3](Arg3: u64)
8MoveLoc[7](loc3: u64)
9Div
10StLoc[12](loc8: u64)
11MoveLoc[0](Arg0: &vector<Validator>)
12StLoc[13](loc9: &vector<Validator>)
13CopyLoc[13](loc9: &vector<Validator>)
14VecLen(58)
15StLoc[4](loc0: u64)
16LdU64(0)
17StLoc[5](loc1: u64)
18MoveLoc[4](loc0: u64)
19StLoc[10](loc6: u64)
B1:
20CopyLoc[5](loc1: u64)
21CopyLoc[10](loc6: u64)
22Lt
23BrFalse(50)
B2:
24CopyLoc[5](loc1: u64)
25StLoc[6](loc2: u64)
26CopyLoc[13](loc9: &vector<Validator>)
27MoveLoc[6](loc2: u64)
28VecImmBorrow(58)
29Call validator::voting_power(&Validator): u64
30CastU128
31CopyLoc[2](Arg2: u64)
32CastU128
33Mul
34CopyLoc[1](Arg1: u64)
35CastU128
36Div
37CastU64
38StLoc[8](loc4: u64)
39MutBorrowLoc[9](loc5: vector<u64>)
40MoveLoc[8](loc4: u64)
41VecPushBack(20)
42MutBorrowLoc[11](loc7: vector<u64>)
43CopyLoc[12](loc8: u64)
44VecPushBack(20)
45MoveLoc[5](loc1: u64)
46LdU64(1)
47Add
48StLoc[5](loc1: u64)
49Branch(20)
B3:
50MoveLoc[13](loc9: &vector<Validator>)
51Pop
52MoveLoc[9](loc5: vector<u64>)
53MoveLoc[11](loc7: vector<u64>)
54Ret
}
compute_adjusted_reward_distribution(Arg0: &vector<Validator>, Arg1: u64, Arg2: u64, Arg3: vector<u64>, Arg4: vector<u64>, Arg5: u64, Arg6: VecMap<u64, u64>, Arg7: u64, Arg8: VecMap<u64, u64>): vector<u64> * vector<u64> {
L9: loc0: u64
L10: loc1: u64
L11: loc2: u64
L12: loc3: u64
L13: loc4: vector<u64>
L14: loc5: u64
L15: loc6: vector<u64>
L16: loc7: u64
L17: loc8: u64
L18: loc9: u64
L19: loc10: u64
L20: loc11: u64
L21: loc12: u64
L22: loc13: u64
L23: loc14: u64
L24: loc15: u64
L25: loc16: u64
L26: loc17: u64
L27: loc18: u64
L28: loc19: u64
B0:
0MoveLoc[1](Arg1: u64)
1MoveLoc[2](Arg2: u64)
2Sub
3StLoc[25](loc16: u64)
4LdConst[21](vector<u64>: 00)
5StLoc[13](loc4: vector<u64>)
6LdConst[21](vector<u64>: 00)
7StLoc[15](loc6: vector<u64>)
8CopyLoc[0](Arg0: &vector<Validator>)
9VecLen(58)
10StLoc[22](loc13: u64)
11CopyLoc[22](loc13: u64)
12ImmBorrowLoc[6](Arg6: VecMap<u64, u64>)
13Call vec_map::length<u64, u64>(&VecMap<u64, u64>): u64
14Sub
15StLoc[23](loc14: u64)
16MoveLoc[22](loc13: u64)
17StLoc[9](loc0: u64)
18LdU64(0)
19StLoc[20](loc11: u64)
20MoveLoc[9](loc0: u64)
21StLoc[24](loc15: u64)
B1:
22CopyLoc[20](loc11: u64)
23CopyLoc[24](loc15: u64)
24Lt
25BrFalse(109)
B2:
26CopyLoc[20](loc11: u64)
27StLoc[21](loc12: u64)
28CopyLoc[0](Arg0: &vector<Validator>)
29CopyLoc[21](loc12: u64)
30VecImmBorrow(58)
31Call validator::voting_power(&Validator): u64
32StLoc[28](loc19: u64)
33ImmBorrowLoc[3](Arg3: vector<u64>)
34CopyLoc[21](loc12: u64)
35VecImmBorrow(20)
36ReadRef
37StLoc[26](loc17: u64)
38ImmBorrowLoc[6](Arg6: VecMap<u64, u64>)
39ImmBorrowLoc[21](loc12: u64)
40Call vec_map::contains<u64, u64>(&VecMap<u64, u64>, &u64): bool
41BrFalse(53)
B3:
42Branch(43)
B4:
43ImmBorrowLoc[6](Arg6: VecMap<u64, u64>)
44ImmBorrowLoc[21](loc12: u64)
45Call vec_map::get<u64, u64>(&VecMap<u64, u64>, &u64): &u64
46ReadRef
47StLoc[16](loc7: u64)
48MoveLoc[26](loc17: u64)
49MoveLoc[16](loc7: u64)
50Sub
51StLoc[10](loc1: u64)
52Branch(67)
B5:
53CopyLoc[5](Arg5: u64)
54CastU128
55MoveLoc[28](loc19: u64)
56CastU128
57Mul
58CopyLoc[25](loc16: u64)
59CastU128
60Div
61CastU64
62StLoc[17](loc8: u64)
63MoveLoc[26](loc17: u64)
64MoveLoc[17](loc8: u64)
65Add
66StLoc[10](loc1: u64)
B6:
67MoveLoc[10](loc1: u64)
68StLoc[12](loc3: u64)
69MutBorrowLoc[13](loc4: vector<u64>)
70MoveLoc[12](loc3: u64)
71VecPushBack(20)
72ImmBorrowLoc[4](Arg4: vector<u64>)
73CopyLoc[21](loc12: u64)
74VecImmBorrow(20)
75ReadRef
76StLoc[27](loc18: u64)
77ImmBorrowLoc[8](Arg8: VecMap<u64, u64>)
78ImmBorrowLoc[21](loc12: u64)
79Call vec_map::contains<u64, u64>(&VecMap<u64, u64>, &u64): bool
80BrFalse(91)
B7:
81ImmBorrowLoc[8](Arg8: VecMap<u64, u64>)
82ImmBorrowLoc[21](loc12: u64)
83Call vec_map::get<u64, u64>(&VecMap<u64, u64>, &u64): &u64
84ReadRef
85StLoc[18](loc9: u64)
86MoveLoc[27](loc18: u64)
87MoveLoc[18](loc9: u64)
88Sub
89StLoc[11](loc2: u64)
90Branch(99)
B8:
91CopyLoc[7](Arg7: u64)
92CopyLoc[23](loc14: u64)
93Div
94StLoc[19](loc10: u64)
95MoveLoc[27](loc18: u64)
96MoveLoc[19](loc10: u64)
97Add
98StLoc[11](loc2: u64)
B9:
99MoveLoc[11](loc2: u64)
100StLoc[14](loc5: u64)
101MutBorrowLoc[15](loc6: vector<u64>)
102MoveLoc[14](loc5: u64)
103VecPushBack(20)
104MoveLoc[20](loc11: u64)
105LdU64(1)
106Add
107StLoc[20](loc11: u64)
108Branch(22)
B10:
109MoveLoc[0](Arg0: &vector<Validator>)
110Pop
111MoveLoc[13](loc4: vector<u64>)
112MoveLoc[15](loc6: vector<u64>)
113Ret
}
distribute_reward(Arg0: &mut vector<Validator>, Arg1: &vector<u64>, Arg2: &vector<u64>, Arg3: &mut Balance<SUI>, Arg4: &mut Balance<SUI>, Arg5: &mut TxContext) {
L6: loc0: u64
L7: loc1: u64
L8: loc2: u64
L9: loc3: u64
L10: loc4: Balance<SUI>
L11: loc5: u64
L12: loc6: u64
L13: loc7: &mut Validator
L14: loc8: address
L15: loc9: u64
L16: loc10: Balance<SUI>
B0:
0CopyLoc[0](Arg0: &mut vector<Validator>)
1FreezeRef
2VecLen(58)
3StLoc[9](loc3: u64)
4CopyLoc[9](loc3: u64)
5LdU64(0)
6Gt
7BrFalse(9)
B1:
8Branch(23)
B2:
9MoveLoc[0](Arg0: &mut vector<Validator>)
10Pop
11MoveLoc[4](Arg4: &mut Balance<SUI>)
12Pop
13MoveLoc[3](Arg3: &mut Balance<SUI>)
14Pop
15MoveLoc[5](Arg5: &mut TxContext)
16Pop
17MoveLoc[2](Arg2: &vector<u64>)
18Pop
19MoveLoc[1](Arg1: &vector<u64>)
20Pop
21LdConst[12](u64: 13)
22Abort
B3:
23MoveLoc[9](loc3: u64)
24StLoc[6](loc0: u64)
25LdU64(0)
26StLoc[7](loc1: u64)
27MoveLoc[6](loc0: u64)
28StLoc[12](loc6: u64)
B4:
29CopyLoc[7](loc1: u64)
30CopyLoc[12](loc6: u64)
31Lt
32BrFalse(101)
B5:
33CopyLoc[7](loc1: u64)
34StLoc[8](loc2: u64)
35CopyLoc[0](Arg0: &mut vector<Validator>)
36CopyLoc[8](loc2: u64)
37VecMutBorrow(58)
38StLoc[13](loc7: &mut Validator)
39CopyLoc[1](Arg1: &vector<u64>)
40CopyLoc[8](loc2: u64)
41VecImmBorrow(20)
42ReadRef
43StLoc[11](loc5: u64)
44CopyLoc[3](Arg3: &mut Balance<SUI>)
45CopyLoc[11](loc5: u64)
46Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
47StLoc[10](loc4: Balance<SUI>)
48MoveLoc[11](loc5: u64)
49CastU128
50CopyLoc[13](loc7: &mut Validator)
51FreezeRef
52Call validator::commission_rate(&Validator): u64
53CastU128
54Mul
55LdConst[19](u64: 10000)
56CastU128
57Div
58CastU64
59StLoc[15](loc9: u64)
60MutBorrowLoc[10](loc4: Balance<SUI>)
61MoveLoc[15](loc9: u64)
62CastU64
63Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
64StLoc[16](loc10: Balance<SUI>)
65MutBorrowLoc[16](loc10: Balance<SUI>)
66CopyLoc[4](Arg4: &mut Balance<SUI>)
67CopyLoc[2](Arg2: &vector<u64>)
68MoveLoc[8](loc2: u64)
69VecImmBorrow(20)
70ReadRef
71Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
72Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
73Pop
74ImmBorrowLoc[16](loc10: Balance<SUI>)
75Call balance::value<SUI>(&Balance<SUI>): u64
76LdU64(0)
77Gt
78BrFalse(91)
B6:
79CopyLoc[13](loc7: &mut Validator)
80FreezeRef
81Call validator::sui_address(&Validator): address
82StLoc[14](loc8: address)
83CopyLoc[13](loc7: &mut Validator)
84MoveLoc[16](loc10: Balance<SUI>)
85CopyLoc[14](loc8: address)
86CopyLoc[5](Arg5: &mut TxContext)
87Call validator::request_add_stake(&mut Validator, Balance<SUI>, address, &mut TxContext): StakedSui
88MoveLoc[14](loc8: address)
89Call transfer::public_transfer<StakedSui>(StakedSui, address)
90Branch(93)
B7:
91MoveLoc[16](loc10: Balance<SUI>)
92Call balance::destroy_zero<SUI>(Balance<SUI>)
B8:
93MoveLoc[13](loc7: &mut Validator)
94MoveLoc[10](loc4: Balance<SUI>)
95Call validator::deposit_stake_rewards(&mut Validator, Balance<SUI>)
96MoveLoc[7](loc1: u64)
97LdU64(1)
98Add
99StLoc[7](loc1: u64)
100Branch(29)
B9:
101MoveLoc[0](Arg0: &mut vector<Validator>)
102Pop
103MoveLoc[4](Arg4: &mut Balance<SUI>)
104Pop
105MoveLoc[3](Arg3: &mut Balance<SUI>)
106Pop
107MoveLoc[5](Arg5: &mut TxContext)
108Pop
109MoveLoc[2](Arg2: &vector<u64>)
110Pop
111MoveLoc[1](Arg1: &vector<u64>)
112Pop
113Ret
}
emit_validator_epoch_events(Arg0: u64, Arg1: &vector<Validator>, Arg2: &vector<u64>, Arg3: &vector<u64>, Arg4: &VecMap<address, VecSet<address>>, Arg5: &vector<address>) {
L6: loc0: u64
L7: loc1: vector<address>
L8: loc2: u64
L9: loc3: u64
L10: loc4: u64
L11: loc5: u64
L12: loc6: u64
L13: loc7: vector<address>
L14: loc8: &Validator
L15: loc9: address
B0:
0CopyLoc[1](Arg1: &vector<Validator>)
1VecLen(58)
2StLoc[6](loc0: u64)
3LdU64(0)
4StLoc[9](loc3: u64)
5MoveLoc[6](loc0: u64)
6StLoc[11](loc5: u64)
B1:
7CopyLoc[9](loc3: u64)
8CopyLoc[11](loc5: u64)
9Lt
10BrFalse(77)
B2:
11CopyLoc[9](loc3: u64)
12StLoc[10](loc4: u64)
13CopyLoc[1](Arg1: &vector<Validator>)
14CopyLoc[10](loc4: u64)
15VecImmBorrow(58)
16StLoc[14](loc8: &Validator)
17CopyLoc[14](loc8: &Validator)
18Call validator::sui_address(&Validator): address
19StLoc[15](loc9: address)
20CopyLoc[4](Arg4: &VecMap<address, VecSet<address>>)
21ImmBorrowLoc[15](loc9: address)
22Call vec_map::contains<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): bool
23BrFalse(32)
B3:
24Branch(25)
B4:
25CopyLoc[4](Arg4: &VecMap<address, VecSet<address>>)
26ImmBorrowLoc[15](loc9: address)
27Call vec_map::get<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): &VecSet<address>
28ReadRef
29Call vec_set::into_keys<address>(VecSet<address>): vector<address>
30StLoc[7](loc1: vector<address>)
31Branch(34)
B5:
32LdConst[22](vector<address>: 00)
33StLoc[7](loc1: vector<address>)
B6:
34MoveLoc[7](loc1: vector<address>)
35StLoc[13](loc7: vector<address>)
36CopyLoc[5](Arg5: &vector<address>)
37ImmBorrowLoc[15](loc9: address)
38Call vector::contains<address>(&vector<address>, &address): bool
39BrFalse(43)
B7:
40LdU64(0)
41StLoc[8](loc2: u64)
42Branch(45)
B8:
43LdU64(1)
44StLoc[8](loc2: u64)
B9:
45MoveLoc[8](loc2: u64)
46StLoc[12](loc6: u64)
47CopyLoc[0](Arg0: u64)
48MoveLoc[15](loc9: address)
49CopyLoc[14](loc8: &Validator)
50Call validator::gas_price(&Validator): u64
51CopyLoc[14](loc8: &Validator)
52Call validator::total_stake(&Validator): u64
53CopyLoc[14](loc8: &Validator)
54Call validator::voting_power(&Validator): u64
55CopyLoc[14](loc8: &Validator)
56Call validator::commission_rate(&Validator): u64
57CopyLoc[2](Arg2: &vector<u64>)
58CopyLoc[10](loc4: u64)
59VecImmBorrow(20)
60ReadRef
61CopyLoc[3](Arg3: &vector<u64>)
62MoveLoc[10](loc4: u64)
63VecImmBorrow(20)
64ReadRef
65MoveLoc[14](loc8: &Validator)
66CopyLoc[0](Arg0: u64)
67Call validator::pool_token_exchange_rate_at_epoch(&Validator, u64): PoolTokenExchangeRate
68MoveLoc[13](loc7: vector<address>)
69MoveLoc[12](loc6: u64)
70Pack[2](ValidatorEpochInfoEventV2)
71Call event::emit<ValidatorEpochInfoEventV2>(ValidatorEpochInfoEventV2)
72MoveLoc[9](loc3: u64)
73LdU64(1)
74Add
75StLoc[9](loc3: u64)
76Branch(7)
B10:
77MoveLoc[1](Arg1: &vector<Validator>)
78Pop
79MoveLoc[3](Arg3: &vector<u64>)
80Pop
81MoveLoc[5](Arg5: &vector<address>)
82Pop
83MoveLoc[4](Arg4: &VecMap<address, VecSet<address>>)
84Pop
85MoveLoc[2](Arg2: &vector<u64>)
86Pop
87Ret
}
public sum_voting_power_by_addresses(Arg0: &vector<Validator>, Arg1: &vector<address>): u64 {
L2: loc0: u64
L3: loc1: &address
L4: loc2: u64
L5: loc3: u64
L6: loc4: u64
L7: loc5: u64
L8: loc6: &vector<address>
L9: loc7: &Validator
B0:
0LdU64(0)
1StLoc[7](loc5: u64)
2MoveLoc[1](Arg1: &vector<address>)
3StLoc[8](loc6: &vector<address>)
4CopyLoc[8](loc6: &vector<address>)
5VecLen(26)
6StLoc[2](loc0: u64)
7LdU64(0)
8StLoc[4](loc2: u64)
9MoveLoc[2](loc0: u64)
10StLoc[6](loc4: u64)
B1:
11CopyLoc[4](loc2: u64)
12CopyLoc[6](loc4: u64)
13Lt
14BrFalse(36)
B2:
15CopyLoc[4](loc2: u64)
16StLoc[5](loc3: u64)
17CopyLoc[8](loc6: &vector<address>)
18MoveLoc[5](loc3: u64)
19VecImmBorrow(26)
20StLoc[3](loc1: &address)
21CopyLoc[0](Arg0: &vector<Validator>)
22MoveLoc[3](loc1: &address)
23ReadRef
24Call get_validator_ref(&vector<Validator>, address): &Validator
25StLoc[9](loc7: &Validator)
26MoveLoc[7](loc5: u64)
27MoveLoc[9](loc7: &Validator)
28Call validator::voting_power(&Validator): u64
29Add
30StLoc[7](loc5: u64)
31MoveLoc[4](loc2: u64)
32LdU64(1)
33Add
34StLoc[4](loc2: u64)
35Branch(11)
B3:
36MoveLoc[0](Arg0: &vector<Validator>)
37Pop
38MoveLoc[8](loc6: &vector<address>)
39Pop
40MoveLoc[7](loc5: u64)
41Ret
}
public active_validators(Arg0: &ValidatorSet): &vector<Validator> {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2Ret
}
public is_validator_candidate(Arg0: &ValidatorSet, Arg1: address): bool {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
2MoveLoc[1](Arg1: address)
3Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
4Ret
}
public(friend) is_active_validator(Arg0: &ValidatorSet, Arg1: address): bool {
L2: loc0: u64
L3: loc1: bool
L4: loc2: u64
L5: loc3: u64
L6: loc4: u64
L7: loc5: &vector<Validator>
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2StLoc[7](loc5: &vector<Validator>)
3CopyLoc[7](loc5: &vector<Validator>)
4VecLen(58)
5StLoc[2](loc0: u64)
6LdU64(0)
7StLoc[5](loc3: u64)
8MoveLoc[2](loc0: u64)
9StLoc[6](loc4: u64)
B1:
10CopyLoc[5](loc3: u64)
11CopyLoc[6](loc4: u64)
12Lt
13BrFalse(33)
B2:
14CopyLoc[5](loc3: u64)
15StLoc[4](loc2: u64)
16CopyLoc[7](loc5: &vector<Validator>)
17MoveLoc[4](loc2: u64)
18VecImmBorrow(58)
19Call validator::sui_address(&Validator): address
20CopyLoc[1](Arg1: address)
21Eq
22BrFalse(28)
B3:
23MoveLoc[7](loc5: &vector<Validator>)
24Pop
25LdTrue
26StLoc[3](loc1: bool)
27Branch(37)
B4:
28MoveLoc[5](loc3: u64)
29LdU64(1)
30Add
31StLoc[5](loc3: u64)
32Branch(10)
B5:
33MoveLoc[7](loc5: &vector<Validator>)
34Pop
35LdFalse
36StLoc[3](loc1: bool)
B6:
37MoveLoc[3](loc1: bool)
38Ret
}
public is_inactive_validator(Arg0: &ValidatorSet, Arg1: ID): bool {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[4](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
2MoveLoc[1](Arg1: ID)
3Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
4Ret
}
public(friend) is_at_risk_validator(Arg0: &ValidatorSet, Arg1: address): bool {
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
2ImmBorrowLoc[1](Arg1: address)
3Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
4Ret
}
public(friend) active_validator_addresses(Arg0: &ValidatorSet): vector<address> {
L1: loc0: u64
L2: loc1: u64
L3: loc2: u64
L4: loc3: vector<address>
L5: loc4: u64
L6: loc5: &vector<Validator>
L7: loc6: &Validator
L8: loc7: &vector<Validator>
B0:
0MoveLoc[0](Arg0: &ValidatorSet)
1ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
2StLoc[8](loc7: &vector<Validator>)
3LdConst[22](vector<address>: 00)
4StLoc[4](loc3: vector<address>)
5MoveLoc[8](loc7: &vector<Validator>)
6StLoc[6](loc5: &vector<Validator>)
7CopyLoc[6](loc5: &vector<Validator>)
8VecLen(58)
9StLoc[1](loc0: u64)
10LdU64(0)
11StLoc[2](loc1: u64)
12MoveLoc[1](loc0: u64)
13StLoc[5](loc4: u64)
B1:
14CopyLoc[2](loc1: u64)
15CopyLoc[5](loc4: u64)
16Lt
17BrFalse(33)
B2:
18CopyLoc[2](loc1: u64)
19StLoc[3](loc2: u64)
20CopyLoc[6](loc5: &vector<Validator>)
21MoveLoc[3](loc2: u64)
22VecImmBorrow(58)
23StLoc[7](loc6: &Validator)
24MutBorrowLoc[4](loc3: vector<address>)
25MoveLoc[7](loc6: &Validator)
26Call validator::sui_address(&Validator): address
27VecPushBack(26)
28MoveLoc[2](loc1: u64)
29LdU64(1)
30Add
31StLoc[2](loc1: u64)
32Branch(14)
B3:
33MoveLoc[6](loc5: &vector<Validator>)
34Pop
35MoveLoc[4](loc3: vector<address>)
36Ret
}
public get_active_validator_ref(Arg0: &ValidatorSet, Arg1: address): &Validator {
B0:
0LdU64(13906840036973740031)
1Abort
}
public get_pending_validator_ref(Arg0: &ValidatorSet, Arg1: address): &Validator {
B0:
0LdU64(13906840058448576511)
1Abort
}
Constants [
0 => u64: 0
1 => u64: 1
2 => u64: 2
3 => u64: 3
4 => u64: 4
5 => u64: 5
6 => u64: 6
7 => u64: 7
8 => u64: 8
9 => u64: 10
10 => u64: 11
11 => u64: 12
12 => u64: 13
13 => u64: 101
14 => u64: 14
15 => u64: 15
16 => u8: 1
17 => u8: 2
18 => u8: 3
19 => u64: 10000
20 => u64: 1000000000
21 => vector<u64>: 00
22 => vector<address>: 00
]
}