tide
SUI$0.95246.40%DEEP$0.01664.93%WAL$0.03035.38%NAVX$0.009371.70%MMT$0.12633.57%USDT$0.99910.01%

Search by name, SuiNS, address, digest, object ID, coin type or checkpoint.

API

staking

Module0x126e…2a62
Move path
0xbde4…f47d::staking
Functions
7346 public, 0 entry
Structs
20
Friend modules
breakermanageminorsignoperaterobot
staking

Bytecode3571 lines

The on-chain disassembly. Offsets are bytecode positions within each function.

// Move bytecode v6
module bde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d.staking {
use bde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::config;
use bde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::hasui;
use bde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::table_queue;
use bde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::util;
use bde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::vault;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::sui;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000003::staking_pool;
use 0000000000000000000000000000000000000000000000000000000000000003::sui_system;
 
struct Staking has key {
id: UID,
version: u64,
config: StakingConfig,
sui_vault: Vault<SUI>,
claim_sui_vault: Vault<SUI>,
protocol_sui_vault: Vault<SUI>,
service_sui_vault: Vault<SUI>,
stsui_treasury_cap: TreasuryCap<HASUI>,
unstake_epochs: vector<EpochClaim>,
total_staked: u64,
total_unstaked: u64,
total_rewards: u64,
total_protocol_fees: u64,
uncollected_protocol_fees: u64,
stsui_supply: u64,
unclaimed_sui_amount: u64,
pause_stake: bool,
pause_unstake: bool,
validators: vector<address>,
pools: Table<address, PoolInfo>,
user_selected_validator_bals: VecMap<address, Balance<SUI>>,
rewards_last_updated_epoch: u64
}
 
struct PoolInfo has store {
staked_suis: TableQueue<StakedSui>,
total_staked: u64,
rewards: u64
}
 
struct EpochClaim has store {
epoch: u64,
amount: u64,
approved: bool
}
 
struct UnstakeTicket has key {
id: UID,
unstake_timestamp_ms: u64,
st_amount: u64,
sui_amount: u64,
claim_epoch: u64,
claim_timestamp_ms: u64
}
 
struct UserStaked has copy, drop {
owner: address,
sui_amount: u64,
st_amount: u64,
validator: address
}
 
struct UserInstantUnstaked has copy, drop {
owner: address,
sui_amount: u64,
st_amount: u64
}
 
struct UserNormalUnstaked has copy, drop {
owner: address,
epoch: u64,
epoch_timestamp_ms: u64,
unstake_timestamp_ms: u64,
sui_amount: u64,
st_amount: u64
}
 
struct UserClaimed has copy, drop {
id: ID,
owner: address,
sui_amount: u64
}
 
struct SystemStaked has copy, drop {
staked_sui_id: ID,
epoch: u64,
sui_amount: u64,
validator: address
}
 
struct SystemUnstaked has copy, drop {
epoch: u64,
sui_amount: u64,
approved_amount: u64
}
 
struct PoolSystemUnstaked has copy, drop {
validator: address,
epoch: u64,
sui_amount: u64,
unstaked_all: bool
}
 
struct SuiRewardsUpdated has copy, drop {
old: u64,
new: u64,
fee: u64
}
 
struct RewardsFeeCollected has copy, drop {
owner: address,
sui_amount: u64
}
 
struct ServiceFeeCollected has copy, drop {
owner: address,
sui_amount: u64
}
 
struct VersionUpdated has copy, drop {
old: u64,
new: u64
}
 
struct ExchangeRateUpdated has copy, drop {
old: u64,
new: u64
}
 
struct RewardsInjected has copy, drop {
owner: address,
sui_amount: u64
}
 
struct ValidatorStakedInfo has store {
validator: address,
total_staked: u64,
rewards: u64,
staked_sui_count: u64
}
 
struct ValidatorStakedInfoV2 has store {
validator: address,
total_staked: u64,
rewards: u64,
staked_sui_count: u64,
pool_id: ID,
exchange_rates_unexisted_epoches: vector<u64>,
stake_activation_epoches: vector<u64>
}
 
struct UserSelectedStaking has drop {
validator: address,
amount: u64
}
 
public(friend) initialize(Arg0: TreasuryCap<HASUI>, Arg1: &mut TxContext) {
L2: loc0: StakingConfig
B0:
0LdConst[1](u64: 0)
1LdConst[2](u64: 1000..)
2LdConst[1](u64: 0)
3LdConst[3](u64: 900000)
4LdConst[5](u64: 7200..)
5LdConst[7](u64: 10)
6Call config::new(u64, u64, u64, u64, u64, u64): StakingConfig
7StLoc[2](loc0: StakingConfig)
8CopyLoc[1](Arg1: &mut TxContext)
9Call object::new(&mut TxContext): UID
10LdConst[10](u64: 5)
11MoveLoc[2](loc0: StakingConfig)
12CopyLoc[1](Arg1: &mut TxContext)
13Call vault::new<SUI>(&mut TxContext): Vault<SUI>
14CopyLoc[1](Arg1: &mut TxContext)
15Call vault::new<SUI>(&mut TxContext): Vault<SUI>
16CopyLoc[1](Arg1: &mut TxContext)
17Call vault::new<SUI>(&mut TxContext): Vault<SUI>
18CopyLoc[1](Arg1: &mut TxContext)
19Call vault::new<SUI>(&mut TxContext): Vault<SUI>
20MoveLoc[0](Arg0: TreasuryCap<HASUI>)
21VecPack(59, 0)
22LdU64(0)
23LdU64(0)
24LdU64(0)
25LdU64(0)
26LdU64(0)
27LdU64(0)
28LdU64(0)
29LdFalse
30LdFalse
31VecPack(60, 0)
32MoveLoc[1](Arg1: &mut TxContext)
33Call table::new<address, PoolInfo>(&mut TxContext): Table<address, PoolInfo>
34Call vec_map::empty<address, Balance<SUI>>(): VecMap<address, Balance<SUI>>
35LdU64(0)
36Pack[0](Staking)
37Call transfer::share_object<Staking>(Staking)
38Ret
}
 
public inject_rewards(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: Coin<SUI>, Arg3: &mut TxContext) {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
B0:
0CopyLoc[1](Arg1: &mut Staking)
1FreezeRef
2Call assert_version(&Staking)
3ImmBorrowLoc[2](Arg2: Coin<SUI>)
4Call coin::value<SUI>(&Coin<SUI>): u64
5StLoc[4](loc0: u64)
6CopyLoc[4](loc0: u64)
7LdU64(0)
8Gt
9BrFalse(11)
B1:
10Branch(17)
B2:
11MoveLoc[1](Arg1: &mut Staking)
12Pop
13MoveLoc[3](Arg3: &mut TxContext)
14Pop
15LdConst[26](u64: 20)
16Abort
B3:
17CopyLoc[1](Arg1: &mut Staking)
18ImmBorrowField[0](Staking.stsui_supply: u64)
19ReadRef
20LdU64(0)
21Gt
22BrFalse(24)
B4:
23Branch(30)
B5:
24MoveLoc[1](Arg1: &mut Staking)
25Pop
26MoveLoc[3](Arg3: &mut TxContext)
27Pop
28LdConst[11](u64: 1)
29Abort
B6:
30CopyLoc[1](Arg1: &mut Staking)
31MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
32MoveLoc[2](Arg2: Coin<SUI>)
33Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
34Call vault::deposit<SUI>(&mut Vault<SUI>, Balance<SUI>)
35CopyLoc[1](Arg1: &mut Staking)
36FreezeRef
37Call get_exchange_rate(&Staking): u64
38StLoc[5](loc1: u64)
39CopyLoc[1](Arg1: &mut Staking)
40ImmBorrowField[2](Staking.total_rewards: u64)
41ReadRef
42StLoc[6](loc2: u64)
43CopyLoc[1](Arg1: &mut Staking)
44ImmBorrowField[2](Staking.total_rewards: u64)
45ReadRef
46CopyLoc[4](loc0: u64)
47Add
48CopyLoc[1](Arg1: &mut Staking)
49MutBorrowField[2](Staking.total_rewards: u64)
50WriteRef
51MoveLoc[3](Arg3: &mut TxContext)
52FreezeRef
53Call tx_context::sender(&TxContext): address
54MoveLoc[4](loc0: u64)
55Pack[16](RewardsInjected)
56Call event::emit<RewardsInjected>(RewardsInjected)
57MoveLoc[6](loc2: u64)
58CopyLoc[1](Arg1: &mut Staking)
59ImmBorrowField[2](Staking.total_rewards: u64)
60ReadRef
61LdU64(0)
62Pack[11](SuiRewardsUpdated)
63Call event::emit<SuiRewardsUpdated>(SuiRewardsUpdated)
64MoveLoc[5](loc1: u64)
65MoveLoc[1](Arg1: &mut Staking)
66FreezeRef
67Call get_exchange_rate(&Staking): u64
68Pack[15](ExchangeRateUpdated)
69Call event::emit<ExchangeRateUpdated>(ExchangeRateUpdated)
70Ret
}
 
public request_stake_coin(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: Coin<SUI>, Arg3: address, Arg4: &mut TxContext): Coin<HASUI> {
L5: loc0: u64
L6: loc1: bool
L7: loc2: vector<address>
L8: loc3: u64
L9: loc4: u64
L10: loc5: Coin<HASUI>
L11: loc6: address
B0:
0CopyLoc[1](Arg1: &mut Staking)
1FreezeRef
2Call assert_version(&Staking)
3CopyLoc[1](Arg1: &mut Staking)
4ImmBorrowField[3](Staking.pause_stake: bool)
5ReadRef
6Not
7BrFalse(9)
B1:
8Branch(17)
B2:
9MoveLoc[0](Arg0: &mut SuiSystemState)
10Pop
11MoveLoc[1](Arg1: &mut Staking)
12Pop
13MoveLoc[4](Arg4: &mut TxContext)
14Pop
15LdConst[20](u64: 12)
16Abort
B3:
17ImmBorrowLoc[2](Arg2: Coin<SUI>)
18Call coin::value<SUI>(&Coin<SUI>): u64
19StLoc[9](loc4: u64)
20CopyLoc[9](loc4: u64)
21LdConst[0](u64: 1000..)
22Ge
23BrFalse(25)
B4:
24Branch(33)
B5:
25MoveLoc[0](Arg0: &mut SuiSystemState)
26Pop
27MoveLoc[1](Arg1: &mut Staking)
28Pop
29MoveLoc[4](Arg4: &mut TxContext)
30Pop
31LdConst[14](u64: 4)
32Abort
B6:
33CopyLoc[1](Arg1: &mut Staking)
34CopyLoc[9](loc4: u64)
35StLoc[5](loc0: u64)
36FreezeRef
37MoveLoc[5](loc0: u64)
38Call get_stsui_by_sui(&Staking, u64): u64
39StLoc[8](loc3: u64)
40CopyLoc[8](loc3: u64)
41LdU64(0)
42Gt
43BrFalse(45)
B7:
44Branch(53)
B8:
45MoveLoc[0](Arg0: &mut SuiSystemState)
46Pop
47MoveLoc[1](Arg1: &mut Staking)
48Pop
49MoveLoc[4](Arg4: &mut TxContext)
50Pop
51LdConst[10](u64: 5)
52Abort
B9:
53CopyLoc[4](Arg4: &mut TxContext)
54FreezeRef
55Call tx_context::sender(&TxContext): address
56StLoc[11](loc6: address)
57CopyLoc[1](Arg1: &mut Staking)
58MutBorrowField[4](Staking.stsui_treasury_cap: TreasuryCap<HASUI>)
59CopyLoc[8](loc3: u64)
60MoveLoc[4](Arg4: &mut TxContext)
61Call coin::mint<HASUI>(&mut TreasuryCap<HASUI>, u64, &mut TxContext): Coin<HASUI>
62StLoc[10](loc5: Coin<HASUI>)
63MoveLoc[0](Arg0: &mut SuiSystemState)
64Call sui_system::active_validator_addresses(&mut SuiSystemState): vector<address>
65StLoc[7](loc2: vector<address>)
66CopyLoc[3](Arg3: address)
67LdConst[27](address: 0x00..)
68Eq
69BrFalse(73)
B10:
70LdTrue
71StLoc[6](loc1: bool)
72Branch(78)
B11:
73CopyLoc[3](Arg3: address)
74ImmBorrowLoc[7](loc2: vector<address>)
75Call is_active_validator(address, &vector<address>): bool
76Not
77StLoc[6](loc1: bool)
B12:
78MoveLoc[6](loc1: bool)
79BrFalse(86)
B13:
80CopyLoc[1](Arg1: &mut Staking)
81MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
82MoveLoc[2](Arg2: Coin<SUI>)
83Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
84Call vault::deposit<SUI>(&mut Vault<SUI>, Balance<SUI>)
85Branch(90)
B14:
86CopyLoc[1](Arg1: &mut Staking)
87MoveLoc[2](Arg2: Coin<SUI>)
88CopyLoc[3](Arg3: address)
89Call save_user_selected_staking(&mut Staking, Coin<SUI>, address)
B15:
90CopyLoc[1](Arg1: &mut Staking)
91ImmBorrowField[5](Staking.total_staked: u64)
92ReadRef
93CopyLoc[9](loc4: u64)
94Add
95CopyLoc[1](Arg1: &mut Staking)
96MutBorrowField[5](Staking.total_staked: u64)
97WriteRef
98CopyLoc[1](Arg1: &mut Staking)
99ImmBorrowField[4](Staking.stsui_treasury_cap: TreasuryCap<HASUI>)
100Call coin::total_supply<HASUI>(&TreasuryCap<HASUI>): u64
101MoveLoc[1](Arg1: &mut Staking)
102MutBorrowField[0](Staking.stsui_supply: u64)
103WriteRef
104MoveLoc[11](loc6: address)
105MoveLoc[9](loc4: u64)
106MoveLoc[8](loc3: u64)
107MoveLoc[3](Arg3: address)
108Pack[4](UserStaked)
109Call event::emit<UserStaked>(UserStaked)
110MoveLoc[10](loc5: Coin<HASUI>)
111Ret
}
 
public import_stake_sui_vec(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: vector<StakedSui>, Arg3: address, Arg4: &mut TxContext): Coin<HASUI> {
L5: loc0: Balance<SUI>
L6: loc1: Balance<SUI>
B0:
0Call balance::zero<SUI>(): Balance<SUI>
1StLoc[5](loc0: Balance<SUI>)
B1:
2ImmBorrowLoc[2](Arg2: vector<StakedSui>)
3VecLen(83)
4LdU64(0)
5Gt
6BrFalse(19)
B2:
7Branch(8)
B3:
8CopyLoc[0](Arg0: &mut SuiSystemState)
9MutBorrowLoc[2](Arg2: vector<StakedSui>)
10VecPopBack(83)
11CopyLoc[4](Arg4: &mut TxContext)
12Call sui_system::request_withdraw_stake_non_entry(&mut SuiSystemState, StakedSui, &mut TxContext): Balance<SUI>
13StLoc[6](loc1: Balance<SUI>)
14MutBorrowLoc[5](loc0: Balance<SUI>)
15MoveLoc[6](loc1: Balance<SUI>)
16Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
17Pop
18Branch(2)
B4:
19MoveLoc[2](Arg2: vector<StakedSui>)
20VecUnpack(83, 0)
21MoveLoc[0](Arg0: &mut SuiSystemState)
22MoveLoc[1](Arg1: &mut Staking)
23MoveLoc[5](loc0: Balance<SUI>)
24CopyLoc[4](Arg4: &mut TxContext)
25Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
26MoveLoc[3](Arg3: address)
27MoveLoc[4](Arg4: &mut TxContext)
28Call request_stake_coin(&mut SuiSystemState, &mut Staking, Coin<SUI>, address, &mut TxContext): Coin<HASUI>
29Ret
}
 
save_user_selected_staking(Arg0: &mut Staking, Arg1: Coin<SUI>, Arg2: address) {
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
2ImmBorrowLoc[2](Arg2: address)
3Call vec_map::contains<address, Balance<SUI>>(&VecMap<address, Balance<SUI>>, &address): bool
4Not
5BrFalse(11)
B1:
6CopyLoc[0](Arg0: &mut Staking)
7MutBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
8CopyLoc[2](Arg2: address)
9Call balance::zero<SUI>(): Balance<SUI>
10Call vec_map::insert<address, Balance<SUI>>(&mut VecMap<address, Balance<SUI>>, address, Balance<SUI>)
B2:
11MoveLoc[0](Arg0: &mut Staking)
12MutBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
13ImmBorrowLoc[2](Arg2: address)
14Call vec_map::get_mut<address, Balance<SUI>>(&mut VecMap<address, Balance<SUI>>, &address): &mut Balance<SUI>
15MoveLoc[1](Arg1: Coin<SUI>)
16Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
17Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
18Pop
19Ret
}
 
public request_unstake_instant(Arg0: &mut Staking, Arg1: Coin<HASUI>, Arg2: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
 
public request_unstake_instant_v2(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: Coin<HASUI>, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut SuiSystemState)
1MoveLoc[1](Arg1: &mut Staking)
2MoveLoc[2](Arg2: Coin<HASUI>)
3CopyLoc[3](Arg3: &mut TxContext)
4Call request_unstake_instant_coin(&mut SuiSystemState, &mut Staking, Coin<HASUI>, &mut TxContext): Coin<SUI>
5MoveLoc[3](Arg3: &mut TxContext)
6FreezeRef
7Call tx_context::sender(&TxContext): address
8Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
9Ret
}
 
public request_unstake_instant_coin(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: Coin<HASUI>, Arg3: &mut TxContext): Coin<SUI> {
L4: loc0: u64
L5: loc1: bool
L6: loc2: Balance<SUI>
L7: loc3: u64
L8: loc4: Balance<SUI>
L9: loc5: u64
L10: loc6: u64
L11: loc7: address
L12: loc8: u64
B0:
0CopyLoc[1](Arg1: &mut Staking)
1FreezeRef
2Call assert_version(&Staking)
3CopyLoc[1](Arg1: &mut Staking)
4ImmBorrowField[7](Staking.pause_unstake: bool)
5ReadRef
6Not
7BrFalse(9)
B1:
8Branch(17)
B2:
9MoveLoc[0](Arg0: &mut SuiSystemState)
10Pop
11MoveLoc[1](Arg1: &mut Staking)
12Pop
13MoveLoc[3](Arg3: &mut TxContext)
14Pop
15LdConst[21](u64: 13)
16Abort
B3:
17ImmBorrowLoc[2](Arg2: Coin<HASUI>)
18Call coin::value<HASUI>(&Coin<HASUI>): u64
19StLoc[9](loc5: u64)
20CopyLoc[1](Arg1: &mut Staking)
21CopyLoc[9](loc5: u64)
22StLoc[4](loc0: u64)
23FreezeRef
24MoveLoc[4](loc0: u64)
25Call get_sui_by_stsui(&Staking, u64): u64
26StLoc[10](loc6: u64)
27CopyLoc[9](loc5: u64)
28LdU64(0)
29Gt
30BrFalse(32)
B4:
31Branch(40)
B5:
32MoveLoc[0](Arg0: &mut SuiSystemState)
33Pop
34MoveLoc[1](Arg1: &mut Staking)
35Pop
36MoveLoc[3](Arg3: &mut TxContext)
37Pop
38LdConst[19](u64: 11)
39Abort
B6:
40CopyLoc[10](loc6: u64)
41CopyLoc[1](Arg1: &mut Staking)
42FreezeRef
43Call get_total_sui(&Staking): u64
44Le
45BrFalse(51)
B7:
46CopyLoc[10](loc6: u64)
47LdConst[0](u64: 1000..)
48Ge
49StLoc[5](loc1: bool)
50Branch(53)
B8:
51LdFalse
52StLoc[5](loc1: bool)
B9:
53MoveLoc[5](loc1: bool)
54BrFalse(56)
B10:
55Branch(64)
B11:
56MoveLoc[0](Arg0: &mut SuiSystemState)
57Pop
58MoveLoc[1](Arg1: &mut Staking)
59Pop
60MoveLoc[3](Arg3: &mut TxContext)
61Pop
62LdConst[17](u64: 8)
63Abort
B12:
64CopyLoc[3](Arg3: &mut TxContext)
65FreezeRef
66Call tx_context::sender(&TxContext): address
67StLoc[11](loc7: address)
68MoveLoc[0](Arg0: &mut SuiSystemState)
69CopyLoc[1](Arg1: &mut Staking)
70CopyLoc[10](loc6: u64)
71LdTrue
72CopyLoc[3](Arg3: &mut TxContext)
73Call withdraw_sui(&mut SuiSystemState, &mut Staking, u64, bool, &mut TxContext): Balance<SUI>
74StLoc[6](loc2: Balance<SUI>)
75CopyLoc[1](Arg1: &mut Staking)
76ImmBorrowField[8](Staking.config: StakingConfig)
77Call config::get_service_fee(&StakingConfig): u64
78StLoc[12](loc8: u64)
79CopyLoc[10](loc6: u64)
80CastU128
81MoveLoc[12](loc8: u64)
82CastU128
83Mul
84LdConst[4](u64: 1000..)
85CastU128
86Div
87CastU64
88StLoc[7](loc3: u64)
89MutBorrowLoc[6](loc2: Balance<SUI>)
90MoveLoc[7](loc3: u64)
91Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
92StLoc[8](loc4: Balance<SUI>)
93CopyLoc[1](Arg1: &mut Staking)
94MutBorrowField[9](Staking.service_sui_vault: Vault<SUI>)
95MoveLoc[8](loc4: Balance<SUI>)
96Call vault::deposit<SUI>(&mut Vault<SUI>, Balance<SUI>)
97CopyLoc[1](Arg1: &mut Staking)
98MutBorrowField[4](Staking.stsui_treasury_cap: TreasuryCap<HASUI>)
99MoveLoc[2](Arg2: Coin<HASUI>)
100Call coin::burn<HASUI>(&mut TreasuryCap<HASUI>, Coin<HASUI>): u64
101Pop
102MoveLoc[11](loc7: address)
103CopyLoc[10](loc6: u64)
104MoveLoc[9](loc5: u64)
105Pack[5](UserInstantUnstaked)
106Call event::emit<UserInstantUnstaked>(UserInstantUnstaked)
107CopyLoc[1](Arg1: &mut Staking)
108ImmBorrowField[10](Staking.total_unstaked: u64)
109ReadRef
110MoveLoc[10](loc6: u64)
111Add
112CopyLoc[1](Arg1: &mut Staking)
113MutBorrowField[10](Staking.total_unstaked: u64)
114WriteRef
115CopyLoc[1](Arg1: &mut Staking)
116ImmBorrowField[4](Staking.stsui_treasury_cap: TreasuryCap<HASUI>)
117Call coin::total_supply<HASUI>(&TreasuryCap<HASUI>): u64
118MoveLoc[1](Arg1: &mut Staking)
119MutBorrowField[0](Staking.stsui_supply: u64)
120WriteRef
121MoveLoc[6](loc2: Balance<SUI>)
122MoveLoc[3](Arg3: &mut TxContext)
123Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
124Ret
}
 
public request_unstake_delay(Arg0: &mut Staking, Arg1: &Clock, Arg2: Coin<HASUI>, Arg3: &mut TxContext) {
L4: loc0: u64
L5: loc1: bool
L6: loc2: u64
L7: loc3: u64
L8: loc4: u64
L9: loc5: u64
L10: loc6: u64
L11: loc7: u64
L12: loc8: u64
L13: loc9: u64
L14: loc10: address
L15: loc11: UnstakeTicket
B0:
0CopyLoc[0](Arg0: &mut Staking)
1FreezeRef
2Call assert_version(&Staking)
3CopyLoc[0](Arg0: &mut Staking)
4ImmBorrowField[7](Staking.pause_unstake: bool)
5ReadRef
6Not
7BrFalse(9)
B1:
8Branch(17)
B2:
9MoveLoc[0](Arg0: &mut Staking)
10Pop
11MoveLoc[3](Arg3: &mut TxContext)
12Pop
13MoveLoc[1](Arg1: &Clock)
14Pop
15LdConst[21](u64: 13)
16Abort
B3:
17ImmBorrowLoc[2](Arg2: Coin<HASUI>)
18Call coin::value<HASUI>(&Coin<HASUI>): u64
19StLoc[10](loc6: u64)
20CopyLoc[0](Arg0: &mut Staking)
21CopyLoc[10](loc6: u64)
22StLoc[4](loc0: u64)
23FreezeRef
24MoveLoc[4](loc0: u64)
25Call get_sui_by_stsui(&Staking, u64): u64
26StLoc[12](loc8: u64)
27CopyLoc[10](loc6: u64)
28LdU64(0)
29Gt
30BrFalse(32)
B4:
31Branch(40)
B5:
32MoveLoc[0](Arg0: &mut Staking)
33Pop
34MoveLoc[3](Arg3: &mut TxContext)
35Pop
36MoveLoc[1](Arg1: &Clock)
37Pop
38LdConst[19](u64: 11)
39Abort
B6:
40CopyLoc[12](loc8: u64)
41CopyLoc[0](Arg0: &mut Staking)
42FreezeRef
43Call get_total_sui(&Staking): u64
44Le
45BrFalse(51)
B7:
46CopyLoc[12](loc8: u64)
47LdConst[0](u64: 1000..)
48Ge
49StLoc[5](loc1: bool)
50Branch(53)
B8:
51LdFalse
52StLoc[5](loc1: bool)
B9:
53MoveLoc[5](loc1: bool)
54BrFalse(56)
B10:
55Branch(64)
B11:
56MoveLoc[0](Arg0: &mut Staking)
57Pop
58MoveLoc[3](Arg3: &mut TxContext)
59Pop
60MoveLoc[1](Arg1: &Clock)
61Pop
62LdConst[17](u64: 8)
63Abort
B12:
64CopyLoc[3](Arg3: &mut TxContext)
65FreezeRef
66Call tx_context::epoch(&TxContext): u64
67StLoc[8](loc4: u64)
68CopyLoc[3](Arg3: &mut TxContext)
69FreezeRef
70Call tx_context::epoch_timestamp_ms(&TxContext): u64
71StLoc[9](loc5: u64)
72MoveLoc[1](Arg1: &Clock)
73Call clock::timestamp_ms(&Clock): u64
74StLoc[13](loc9: u64)
75LdConst[6](u64: 8640..)
76StLoc[6](loc2: u64)
77CopyLoc[8](loc4: u64)
78LdU64(1)
79Add
80StLoc[7](loc3: u64)
81CopyLoc[0](Arg0: &mut Staking)
82ImmBorrowField[8](Staking.config: StakingConfig)
83Call config::get_withdraw_time_limit(&StakingConfig): u64
84StLoc[11](loc7: u64)
85CopyLoc[13](loc9: u64)
86CopyLoc[9](loc5: u64)
87MoveLoc[11](loc7: u64)
88Add
89Gt
90BrFalse(99)
B13:
91MoveLoc[7](loc3: u64)
92LdU64(1)
93Add
94StLoc[7](loc3: u64)
95MoveLoc[6](loc2: u64)
96LdConst[6](u64: 8640..)
97Add
98StLoc[6](loc2: u64)
B14:
99CopyLoc[3](Arg3: &mut TxContext)
100Call object::new(&mut TxContext): UID
101CopyLoc[13](loc9: u64)
102CopyLoc[10](loc6: u64)
103CopyLoc[12](loc8: u64)
104MoveLoc[7](loc3: u64)
105CopyLoc[9](loc5: u64)
106MoveLoc[6](loc2: u64)
107Add
108Pack[3](UnstakeTicket)
109StLoc[15](loc11: UnstakeTicket)
110MoveLoc[3](Arg3: &mut TxContext)
111FreezeRef
112Call tx_context::sender(&TxContext): address
113StLoc[14](loc10: address)
114MoveLoc[15](loc11: UnstakeTicket)
115CopyLoc[14](loc10: address)
116Call transfer::transfer<UnstakeTicket>(UnstakeTicket, address)
117CopyLoc[0](Arg0: &mut Staking)
118MutBorrowField[4](Staking.stsui_treasury_cap: TreasuryCap<HASUI>)
119MoveLoc[2](Arg2: Coin<HASUI>)
120Call coin::burn<HASUI>(&mut TreasuryCap<HASUI>, Coin<HASUI>): u64
121Pop
122MoveLoc[14](loc10: address)
123MoveLoc[8](loc4: u64)
124MoveLoc[9](loc5: u64)
125MoveLoc[13](loc9: u64)
126CopyLoc[12](loc8: u64)
127MoveLoc[10](loc6: u64)
128Pack[6](UserNormalUnstaked)
129Call event::emit<UserNormalUnstaked>(UserNormalUnstaked)
130CopyLoc[0](Arg0: &mut Staking)
131ImmBorrowField[10](Staking.total_unstaked: u64)
132ReadRef
133CopyLoc[12](loc8: u64)
134Add
135CopyLoc[0](Arg0: &mut Staking)
136MutBorrowField[10](Staking.total_unstaked: u64)
137WriteRef
138CopyLoc[0](Arg0: &mut Staking)
139ImmBorrowField[4](Staking.stsui_treasury_cap: TreasuryCap<HASUI>)
140Call coin::total_supply<HASUI>(&TreasuryCap<HASUI>): u64
141CopyLoc[0](Arg0: &mut Staking)
142MutBorrowField[0](Staking.stsui_supply: u64)
143WriteRef
144CopyLoc[0](Arg0: &mut Staking)
145ImmBorrowField[11](Staking.unclaimed_sui_amount: u64)
146ReadRef
147MoveLoc[12](loc8: u64)
148Add
149MoveLoc[0](Arg0: &mut Staking)
150MutBorrowField[11](Staking.unclaimed_sui_amount: u64)
151WriteRef
152Ret
}
 
public claim(Arg0: &mut Staking, Arg1: UnstakeTicket, Arg2: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
 
public claim_coin(Arg0: &mut Staking, Arg1: UnstakeTicket, Arg2: &mut TxContext): Coin<SUI> {
B0:
0LdU64(0)
1Abort
}
 
public claim_v2(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: UnstakeTicket, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut SuiSystemState)
1MoveLoc[1](Arg1: &mut Staking)
2MoveLoc[2](Arg2: UnstakeTicket)
3CopyLoc[3](Arg3: &mut TxContext)
4Call claim_coin_v2(&mut SuiSystemState, &mut Staking, UnstakeTicket, &mut TxContext): Coin<SUI>
5MoveLoc[3](Arg3: &mut TxContext)
6FreezeRef
7Call tx_context::sender(&TxContext): address
8Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
9Ret
}
 
public claim_coin_v2(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: UnstakeTicket, Arg3: &mut TxContext): Coin<SUI> {
L4: loc0: Balance<SUI>
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
L8: loc4: UID
L9: loc5: ID
L10: loc6: u64
L11: loc7: address
L12: loc8: u64
L13: loc9: u64
B0:
0CopyLoc[1](Arg1: &mut Staking)
1FreezeRef
2Call assert_version(&Staking)
3CopyLoc[1](Arg1: &mut Staking)
4FreezeRef
5Call query_pause_claim(&Staking): bool
6Not
7BrFalse(9)
B1:
8Branch(17)
B2:
9MoveLoc[0](Arg0: &mut SuiSystemState)
10Pop
11MoveLoc[1](Arg1: &mut Staking)
12Pop
13MoveLoc[3](Arg3: &mut TxContext)
14Pop
15LdConst[23](u64: 17)
16Abort
B3:
17MoveLoc[2](Arg2: UnstakeTicket)
18Unpack[3](UnstakeTicket)
19StLoc[6](loc2: u64)
20StLoc[5](loc1: u64)
21StLoc[12](loc8: u64)
22Pop
23Pop
24StLoc[8](loc4: UID)
25ImmBorrowLoc[8](loc4: UID)
26Call object::uid_to_inner(&UID): ID
27StLoc[9](loc5: ID)
28MoveLoc[8](loc4: UID)
29Call object::delete(UID)
30CopyLoc[3](Arg3: &mut TxContext)
31FreezeRef
32Call tx_context::epoch(&TxContext): u64
33StLoc[7](loc3: u64)
34CopyLoc[3](Arg3: &mut TxContext)
35FreezeRef
36Call tx_context::epoch_timestamp_ms(&TxContext): u64
37StLoc[13](loc9: u64)
38MoveLoc[7](loc3: u64)
39MoveLoc[5](loc1: u64)
40Ge
41BrFalse(43)
B4:
42Branch(51)
B5:
43MoveLoc[0](Arg0: &mut SuiSystemState)
44Pop
45MoveLoc[1](Arg1: &mut Staking)
46Pop
47MoveLoc[3](Arg3: &mut TxContext)
48Pop
49LdConst[15](u64: 6)
50Abort
B6:
51MoveLoc[13](loc9: u64)
52MoveLoc[6](loc2: u64)
53Ge
54BrFalse(56)
B7:
55Branch(64)
B8:
56MoveLoc[0](Arg0: &mut SuiSystemState)
57Pop
58MoveLoc[1](Arg1: &mut Staking)
59Pop
60MoveLoc[3](Arg3: &mut TxContext)
61Pop
62LdConst[15](u64: 6)
63Abort
B9:
64CopyLoc[1](Arg1: &mut Staking)
65MutBorrowField[12](Staking.claim_sui_vault: Vault<SUI>)
66CopyLoc[12](loc8: u64)
67Call vault::withdraw_max<SUI>(&mut Vault<SUI>, u64): Balance<SUI> * u64
68StLoc[10](loc6: u64)
69StLoc[4](loc0: Balance<SUI>)
70MutBorrowLoc[4](loc0: Balance<SUI>)
71MoveLoc[0](Arg0: &mut SuiSystemState)
72CopyLoc[1](Arg1: &mut Staking)
73MoveLoc[10](loc6: u64)
74LdFalse
75CopyLoc[3](Arg3: &mut TxContext)
76Call withdraw_sui(&mut SuiSystemState, &mut Staking, u64, bool, &mut TxContext): Balance<SUI>
77Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
78Pop
79CopyLoc[3](Arg3: &mut TxContext)
80FreezeRef
81Call tx_context::sender(&TxContext): address
82StLoc[11](loc7: address)
83CopyLoc[1](Arg1: &mut Staking)
84ImmBorrowField[11](Staking.unclaimed_sui_amount: u64)
85ReadRef
86CopyLoc[12](loc8: u64)
87Sub
88MoveLoc[1](Arg1: &mut Staking)
89MutBorrowField[11](Staking.unclaimed_sui_amount: u64)
90WriteRef
91MoveLoc[9](loc5: ID)
92MoveLoc[11](loc7: address)
93MoveLoc[12](loc8: u64)
94Pack[7](UserClaimed)
95Call event::emit<UserClaimed>(UserClaimed)
96MoveLoc[4](loc0: Balance<SUI>)
97MoveLoc[3](Arg3: &mut TxContext)
98Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
99Ret
}
 
withdraw_sui(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: u64, Arg3: bool, Arg4: &mut TxContext): Balance<SUI> {
L5: loc0: bool
L6: loc1: bool
L7: loc2: Balance<SUI>
L8: loc3: u64
L9: loc4: u64
L10: loc5: u64
L11: loc6: u64
L12: loc7: u64
L13: loc8: u64
L14: loc9: u64
L15: loc10: Balance<SUI>
L16: loc11: address
L17: loc12: address
L18: loc13: &mut Balance<SUI>
L19: loc14: vector<address>
L20: loc15: vector<address>
B0:
0CopyLoc[1](Arg1: &mut Staking)
1MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
2MoveLoc[2](Arg2: u64)
3Call vault::withdraw_max<SUI>(&mut Vault<SUI>, u64): Balance<SUI> * u64
4StLoc[11](loc6: u64)
5StLoc[7](loc2: Balance<SUI>)
6MoveLoc[11](loc6: u64)
7StLoc[2](Arg2: u64)
8MoveLoc[3](Arg3: bool)
9BrFalse(81)
B1:
10CopyLoc[1](Arg1: &mut Staking)
11ImmBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
12Call vec_map::keys<address, Balance<SUI>>(&VecMap<address, Balance<SUI>>): vector<address>
13StLoc[19](loc14: vector<address>)
14LdU64(0)
15StLoc[9](loc4: u64)
16ImmBorrowLoc[19](loc14: vector<address>)
17VecLen(60)
18StLoc[12](loc7: u64)
B2:
19CopyLoc[9](loc4: u64)
20CopyLoc[12](loc7: u64)
21Lt
22BrFalse(29)
B3:
23Branch(24)
B4:
24CopyLoc[2](Arg2: u64)
25LdU64(0)
26Gt
27StLoc[5](loc0: bool)
28Branch(31)
B5:
29LdFalse
30StLoc[5](loc0: bool)
B6:
31MoveLoc[5](loc0: bool)
32BrFalse(81)
B7:
33ImmBorrowLoc[19](loc14: vector<address>)
34CopyLoc[9](loc4: u64)
35VecImmBorrow(60)
36ReadRef
37StLoc[16](loc11: address)
38CopyLoc[1](Arg1: &mut Staking)
39MutBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
40ImmBorrowLoc[16](loc11: address)
41Call vec_map::get_mut<address, Balance<SUI>>(&mut VecMap<address, Balance<SUI>>, &address): &mut Balance<SUI>
42StLoc[18](loc13: &mut Balance<SUI>)
43CopyLoc[18](loc13: &mut Balance<SUI>)
44FreezeRef
45Call balance::value<SUI>(&Balance<SUI>): u64
46StLoc[14](loc9: u64)
47CopyLoc[14](loc9: u64)
48LdU64(0)
49Gt
50BrFalse(74)
B8:
51CopyLoc[14](loc9: u64)
52CopyLoc[2](Arg2: u64)
53Ge
54BrFalse(64)
B9:
55MutBorrowLoc[7](loc2: Balance<SUI>)
56MoveLoc[18](loc13: &mut Balance<SUI>)
57MoveLoc[2](Arg2: u64)
58Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
59Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
60Pop
61LdU64(0)
62StLoc[2](Arg2: u64)
63Branch(73)
B10:
64MoveLoc[2](Arg2: u64)
65MoveLoc[14](loc9: u64)
66Sub
67StLoc[2](Arg2: u64)
68MutBorrowLoc[7](loc2: Balance<SUI>)
69MoveLoc[18](loc13: &mut Balance<SUI>)
70Call balance::withdraw_all<SUI>(&mut Balance<SUI>): Balance<SUI>
71Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
72Pop
B11:
73Branch(76)
B12:
74MoveLoc[18](loc13: &mut Balance<SUI>)
75Pop
B13:
76MoveLoc[9](loc4: u64)
77LdU64(1)
78Add
79StLoc[9](loc4: u64)
80Branch(19)
B14:
81CopyLoc[2](Arg2: u64)
82LdU64(0)
83Gt
84BrFalse(159)
B15:
85CopyLoc[2](Arg2: u64)
86StLoc[11](loc6: u64)
87Call balance::zero<SUI>(): Balance<SUI>
88StLoc[15](loc10: Balance<SUI>)
89CopyLoc[4](Arg4: &mut TxContext)
90FreezeRef
91Call tx_context::epoch(&TxContext): u64
92StLoc[8](loc3: u64)
93CopyLoc[1](Arg1: &mut Staking)
94ImmBorrowField[13](Staking.validators: vector<address>)
95ReadRef
96StLoc[20](loc15: vector<address>)
97ImmBorrowLoc[20](loc15: vector<address>)
98VecLen(60)
99StLoc[13](loc8: u64)
100LdU64(0)
101StLoc[10](loc5: u64)
B16:
102CopyLoc[10](loc5: u64)
103CopyLoc[13](loc8: u64)
104Lt
105BrFalse(112)
B17:
106Branch(107)
B18:
107CopyLoc[2](Arg2: u64)
108LdU64(0)
109Gt
110StLoc[6](loc1: bool)
111Branch(114)
B19:
112LdFalse
113StLoc[6](loc1: bool)
B20:
114MoveLoc[6](loc1: bool)
115BrFalse(135)
B21:
116ImmBorrowLoc[20](loc15: vector<address>)
117CopyLoc[10](loc5: u64)
118VecImmBorrow(60)
119ReadRef
120StLoc[17](loc12: address)
121CopyLoc[1](Arg1: &mut Staking)
122CopyLoc[0](Arg0: &mut SuiSystemState)
123MutBorrowLoc[15](loc10: Balance<SUI>)
124MoveLoc[17](loc12: address)
125MoveLoc[2](Arg2: u64)
126CopyLoc[8](loc3: u64)
127CopyLoc[4](Arg4: &mut TxContext)
128Call do_validator_unstake(&mut Staking, &mut SuiSystemState, &mut Balance<SUI>, address, u64, u64, &mut TxContext): u64
129StLoc[2](Arg2: u64)
130MoveLoc[10](loc5: u64)
131LdU64(1)
132Add
133StLoc[10](loc5: u64)
134Branch(102)
B22:
135MoveLoc[0](Arg0: &mut SuiSystemState)
136Pop
137MoveLoc[4](Arg4: &mut TxContext)
138Pop
139MoveLoc[2](Arg2: u64)
140LdU64(0)
141Eq
142BrFalse(144)
B23:
143Branch(148)
B24:
144MoveLoc[1](Arg1: &mut Staking)
145Pop
146LdConst[22](u64: 16)
147Abort
B25:
148MutBorrowLoc[7](loc2: Balance<SUI>)
149MutBorrowLoc[15](loc10: Balance<SUI>)
150MoveLoc[11](loc6: u64)
151Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
152Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
153Pop
154MoveLoc[1](Arg1: &mut Staking)
155MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
156MoveLoc[15](loc10: Balance<SUI>)
157Call vault::deposit<SUI>(&mut Vault<SUI>, Balance<SUI>)
158Branch(165)
B26:
159MoveLoc[0](Arg0: &mut SuiSystemState)
160Pop
161MoveLoc[1](Arg1: &mut Staking)
162Pop
163MoveLoc[4](Arg4: &mut TxContext)
164Pop
B27:
165MoveLoc[7](loc2: Balance<SUI>)
166Ret
}
 
public assert_version(Arg0: &Staking) {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[14](Staking.version: u64)
2ReadRef
3LdConst[10](u64: 5)
4Le
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[11](u64: 1)
8Abort
B3:
9Ret
}
 
public(friend) migrate(Arg0: &mut Staking) {
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[14](Staking.version: u64)
2ReadRef
3LdConst[10](u64: 5)
4Lt
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &mut Staking)
8Pop
9LdConst[11](u64: 1)
10Abort
B3:
11CopyLoc[0](Arg0: &mut Staking)
12ImmBorrowField[14](Staking.version: u64)
13ReadRef
14LdConst[10](u64: 5)
15Pack[14](VersionUpdated)
16Call event::emit<VersionUpdated>(VersionUpdated)
17LdConst[10](u64: 5)
18MoveLoc[0](Arg0: &mut Staking)
19MutBorrowField[14](Staking.version: u64)
20WriteRef
21Ret
}
 
public(friend) do_stake(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: vector<address>, Arg3: &mut TxContext) {
L4: loc0: vector<address>
L5: loc1: u64
L6: loc2: u64
L7: loc3: Balance<SUI>
L8: loc4: u64
L9: loc5: u64
L10: loc6: u64
L11: loc7: address
L12: loc8: Balance<SUI>
L13: loc9: u64
B0:
0CopyLoc[1](Arg1: &mut SuiSystemState)
1Call sui_system::active_validator_addresses(&mut SuiSystemState): vector<address>
2StLoc[4](loc0: vector<address>)
3CopyLoc[0](Arg0: &mut Staking)
4CopyLoc[1](Arg1: &mut SuiSystemState)
5ImmBorrowLoc[4](loc0: vector<address>)
6CopyLoc[3](Arg3: &mut TxContext)
7Call stake_user_selected_validators(&mut Staking, &mut SuiSystemState, &vector<address>, &mut TxContext): Balance<SUI>
8StLoc[7](loc3: Balance<SUI>)
9CopyLoc[0](Arg0: &mut Staking)
10MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
11MoveLoc[7](loc3: Balance<SUI>)
12Call vault::deposit<SUI>(&mut Vault<SUI>, Balance<SUI>)
13ImmBorrowLoc[2](Arg2: vector<address>)
14VecLen(60)
15StLoc[13](loc9: u64)
16CopyLoc[13](loc9: u64)
17LdU64(0)
18Gt
19BrFalse(21)
B1:
20Branch(29)
B2:
21MoveLoc[1](Arg1: &mut SuiSystemState)
22Pop
23MoveLoc[0](Arg0: &mut Staking)
24Pop
25MoveLoc[3](Arg3: &mut TxContext)
26Pop
27LdConst[13](u64: 3)
28Abort
B3:
29CopyLoc[0](Arg0: &mut Staking)
30ImmBorrowField[8](Staking.config: StakingConfig)
31Call config::get_validator_count(&StakingConfig): u64
32StLoc[6](loc2: u64)
33CopyLoc[6](loc2: u64)
34CopyLoc[13](loc9: u64)
35Lt
36BrFalse(39)
B4:
37MoveLoc[6](loc2: u64)
38StLoc[13](loc9: u64)
B5:
39CopyLoc[0](Arg0: &mut Staking)
40ImmBorrowField[1](Staking.sui_vault: Vault<SUI>)
41Call vault::vault_amount<SUI>(&Vault<SUI>): u64
42StLoc[10](loc6: u64)
43CopyLoc[10](loc6: u64)
44LdConst[0](u64: 1000..)
45Div
46StLoc[9](loc5: u64)
47CopyLoc[9](loc5: u64)
48LdU64(0)
49Eq
50BrFalse(58)
B6:
51MoveLoc[1](Arg1: &mut SuiSystemState)
52Pop
53MoveLoc[0](Arg0: &mut Staking)
54Pop
55MoveLoc[3](Arg3: &mut TxContext)
56Pop
57Ret
B7:
58CopyLoc[13](loc9: u64)
59CopyLoc[9](loc5: u64)
60Gt
61BrFalse(64)
B8:
62MoveLoc[9](loc5: u64)
63StLoc[13](loc9: u64)
B9:
64MoveLoc[10](loc6: u64)
65CopyLoc[13](loc9: u64)
66Div
67StLoc[5](loc1: u64)
68LdU64(0)
69StLoc[8](loc4: u64)
B10:
70CopyLoc[8](loc4: u64)
71CopyLoc[13](loc9: u64)
72Lt
73BrFalse(96)
B11:
74Branch(75)
B12:
75CopyLoc[0](Arg0: &mut Staking)
76MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
77CopyLoc[5](loc1: u64)
78Call vault::withdraw<SUI>(&mut Vault<SUI>, u64): Balance<SUI>
79StLoc[12](loc8: Balance<SUI>)
80ImmBorrowLoc[2](Arg2: vector<address>)
81CopyLoc[8](loc4: u64)
82VecImmBorrow(60)
83ReadRef
84StLoc[11](loc7: address)
85MoveLoc[12](loc8: Balance<SUI>)
86CopyLoc[0](Arg0: &mut Staking)
87CopyLoc[1](Arg1: &mut SuiSystemState)
88MoveLoc[11](loc7: address)
89CopyLoc[3](Arg3: &mut TxContext)
90Call stake_to_validator(Balance<SUI>, &mut Staking, &mut SuiSystemState, address, &mut TxContext)
91MoveLoc[8](loc4: u64)
92LdU64(1)
93Add
94StLoc[8](loc4: u64)
95Branch(70)
B13:
96MoveLoc[1](Arg1: &mut SuiSystemState)
97Pop
98MoveLoc[0](Arg0: &mut Staking)
99Pop
100MoveLoc[3](Arg3: &mut TxContext)
101Pop
102Ret
}
 
public(friend) update_total_rewards_onchain(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: &mut TxContext) {
L3: loc0: u64
L4: loc1: u64
L5: loc2: u64
L6: loc3: u64
L7: loc4: u64
L8: loc5: &mut PoolInfo
L9: loc6: u64
L10: loc7: u64
L11: loc8: u64
L12: loc9: address
L13: loc10: vector<address>
B0:
0LdU64(0)
1StLoc[11](loc8: u64)
2MoveLoc[2](Arg2: &mut TxContext)
3FreezeRef
4Call tx_context::epoch(&TxContext): u64
5StLoc[3](loc0: u64)
6CopyLoc[0](Arg0: &mut Staking)
7ImmBorrowField[15](Staking.rewards_last_updated_epoch: u64)
8ReadRef
9CopyLoc[3](loc0: u64)
10Ge
11BrFalse(17)
B1:
12MoveLoc[1](Arg1: &mut SuiSystemState)
13Pop
14MoveLoc[0](Arg0: &mut Staking)
15Pop
16Ret
B2:
17CopyLoc[0](Arg0: &mut Staking)
18ImmBorrowField[13](Staking.validators: vector<address>)
19ReadRef
20StLoc[13](loc10: vector<address>)
21CopyLoc[0](Arg0: &mut Staking)
22ImmBorrowField[13](Staking.validators: vector<address>)
23VecLen(60)
24StLoc[5](loc2: u64)
25LdU64(0)
26StLoc[4](loc1: u64)
B3:
27CopyLoc[4](loc1: u64)
28CopyLoc[5](loc2: u64)
29Lt
30BrFalse(54)
B4:
31Branch(32)
B5:
32ImmBorrowLoc[13](loc10: vector<address>)
33CopyLoc[4](loc1: u64)
34VecImmBorrow(60)
35ReadRef
36StLoc[12](loc9: address)
37MoveLoc[4](loc1: u64)
38LdU64(1)
39Add
40StLoc[4](loc1: u64)
41CopyLoc[0](Arg0: &mut Staking)
42MutBorrowField[16](Staking.pools: Table<address, PoolInfo>)
43MoveLoc[12](loc9: address)
44Call table::borrow_mut<address, PoolInfo>(&mut Table<address, PoolInfo>, address): &mut PoolInfo
45StLoc[8](loc5: &mut PoolInfo)
46MoveLoc[11](loc8: u64)
47CopyLoc[1](Arg1: &mut SuiSystemState)
48MoveLoc[8](loc5: &mut PoolInfo)
49CopyLoc[3](loc0: u64)
50Call calculate_validator_pool_rewards_increase(&mut SuiSystemState, &mut PoolInfo, u64): u64
51Add
52StLoc[11](loc8: u64)
53Branch(27)
B6:
54MoveLoc[1](Arg1: &mut SuiSystemState)
55Pop
56CopyLoc[0](Arg0: &mut Staking)
57FreezeRef
58Call get_exchange_rate(&Staking): u64
59StLoc[6](loc3: u64)
60CopyLoc[0](Arg0: &mut Staking)
61ImmBorrowField[8](Staking.config: StakingConfig)
62Call config::get_reward_fee(&StakingConfig): u64
63StLoc[9](loc6: u64)
64CopyLoc[11](loc8: u64)
65CastU128
66MoveLoc[9](loc6: u64)
67CastU128
68Mul
69LdConst[4](u64: 1000..)
70CastU128
71Div
72CastU64
73StLoc[10](loc7: u64)
74CopyLoc[0](Arg0: &mut Staking)
75ImmBorrowField[17](Staking.uncollected_protocol_fees: u64)
76ReadRef
77CopyLoc[10](loc7: u64)
78Add
79CopyLoc[0](Arg0: &mut Staking)
80MutBorrowField[17](Staking.uncollected_protocol_fees: u64)
81WriteRef
82CopyLoc[0](Arg0: &mut Staking)
83ImmBorrowField[2](Staking.total_rewards: u64)
84ReadRef
85StLoc[7](loc4: u64)
86CopyLoc[0](Arg0: &mut Staking)
87ImmBorrowField[2](Staking.total_rewards: u64)
88ReadRef
89MoveLoc[11](loc8: u64)
90Add
91CopyLoc[0](Arg0: &mut Staking)
92MutBorrowField[2](Staking.total_rewards: u64)
93WriteRef
94MoveLoc[7](loc4: u64)
95CopyLoc[0](Arg0: &mut Staking)
96ImmBorrowField[2](Staking.total_rewards: u64)
97ReadRef
98MoveLoc[10](loc7: u64)
99Pack[11](SuiRewardsUpdated)
100Call event::emit<SuiRewardsUpdated>(SuiRewardsUpdated)
101MoveLoc[6](loc3: u64)
102CopyLoc[0](Arg0: &mut Staking)
103FreezeRef
104Call get_exchange_rate(&Staking): u64
105Pack[15](ExchangeRateUpdated)
106Call event::emit<ExchangeRateUpdated>(ExchangeRateUpdated)
107MoveLoc[3](loc0: u64)
108MoveLoc[0](Arg0: &mut Staking)
109MutBorrowField[15](Staking.rewards_last_updated_epoch: u64)
110WriteRef
111Ret
}
 
public(friend) update_validator_rewards(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: address, Arg3: &mut TxContext) {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: &mut PoolInfo
L8: loc4: u64
L9: loc5: u64
L10: loc6: u64
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[16](Staking.pools: Table<address, PoolInfo>)
2CopyLoc[2](Arg2: address)
3Call table::contains<address, PoolInfo>(&Table<address, PoolInfo>, address): bool
4Not
5BrFalse(13)
B1:
6MoveLoc[1](Arg1: &mut SuiSystemState)
7Pop
8MoveLoc[0](Arg0: &mut Staking)
9Pop
10MoveLoc[3](Arg3: &mut TxContext)
11Pop
12Ret
B2:
13LdU64(0)
14StLoc[10](loc6: u64)
15MoveLoc[3](Arg3: &mut TxContext)
16FreezeRef
17Call tx_context::epoch(&TxContext): u64
18StLoc[4](loc0: u64)
19CopyLoc[0](Arg0: &mut Staking)
20MutBorrowField[16](Staking.pools: Table<address, PoolInfo>)
21MoveLoc[2](Arg2: address)
22Call table::borrow_mut<address, PoolInfo>(&mut Table<address, PoolInfo>, address): &mut PoolInfo
23StLoc[7](loc3: &mut PoolInfo)
24MoveLoc[10](loc6: u64)
25MoveLoc[1](Arg1: &mut SuiSystemState)
26MoveLoc[7](loc3: &mut PoolInfo)
27MoveLoc[4](loc0: u64)
28Call calculate_validator_pool_rewards_increase(&mut SuiSystemState, &mut PoolInfo, u64): u64
29Add
30StLoc[10](loc6: u64)
31CopyLoc[0](Arg0: &mut Staking)
32FreezeRef
33Call get_exchange_rate(&Staking): u64
34StLoc[5](loc1: u64)
35CopyLoc[0](Arg0: &mut Staking)
36ImmBorrowField[8](Staking.config: StakingConfig)
37Call config::get_reward_fee(&StakingConfig): u64
38StLoc[8](loc4: u64)
39CopyLoc[10](loc6: u64)
40CastU128
41MoveLoc[8](loc4: u64)
42CastU128
43Mul
44LdConst[4](u64: 1000..)
45CastU128
46Div
47CastU64
48StLoc[9](loc5: u64)
49CopyLoc[0](Arg0: &mut Staking)
50ImmBorrowField[17](Staking.uncollected_protocol_fees: u64)
51ReadRef
52CopyLoc[9](loc5: u64)
53Add
54CopyLoc[0](Arg0: &mut Staking)
55MutBorrowField[17](Staking.uncollected_protocol_fees: u64)
56WriteRef
57CopyLoc[0](Arg0: &mut Staking)
58ImmBorrowField[2](Staking.total_rewards: u64)
59ReadRef
60StLoc[6](loc2: u64)
61CopyLoc[0](Arg0: &mut Staking)
62ImmBorrowField[2](Staking.total_rewards: u64)
63ReadRef
64MoveLoc[10](loc6: u64)
65Add
66CopyLoc[0](Arg0: &mut Staking)
67MutBorrowField[2](Staking.total_rewards: u64)
68WriteRef
69MoveLoc[6](loc2: u64)
70CopyLoc[0](Arg0: &mut Staking)
71ImmBorrowField[2](Staking.total_rewards: u64)
72ReadRef
73MoveLoc[9](loc5: u64)
74Pack[11](SuiRewardsUpdated)
75Call event::emit<SuiRewardsUpdated>(SuiRewardsUpdated)
76MoveLoc[5](loc1: u64)
77MoveLoc[0](Arg0: &mut Staking)
78FreezeRef
79Call get_exchange_rate(&Staking): u64
80Pack[15](ExchangeRateUpdated)
81Call event::emit<ExchangeRateUpdated>(ExchangeRateUpdated)
82Ret
}
 
public(friend) do_unstake_onchain_by_validator(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: vector<address>, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1MoveLoc[1](Arg1: &mut SuiSystemState)
2MoveLoc[3](Arg3: &mut TxContext)
3Call unstake_inactive_validators(&mut Staking, &mut SuiSystemState, &mut TxContext)
4Ret
}
 
public(friend) unstake_inactive_validators(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: &mut TxContext) {
L3: loc0: vector<address>
L4: loc1: u64
L5: loc2: vector<address>
L6: loc3: u64
L7: loc4: address
B0:
0CopyLoc[1](Arg1: &mut SuiSystemState)
1Call sui_system::active_validator_addresses(&mut SuiSystemState): vector<address>
2StLoc[3](loc0: vector<address>)
3VecPack(60, 0)
4StLoc[5](loc2: vector<address>)
5CopyLoc[0](Arg0: &mut Staking)
6ImmBorrowField[13](Staking.validators: vector<address>)
7VecLen(60)
8StLoc[6](loc3: u64)
9LdU64(0)
10StLoc[4](loc1: u64)
B1:
11CopyLoc[4](loc1: u64)
12CopyLoc[6](loc3: u64)
13Lt
14BrFalse(35)
B2:
15Branch(16)
B3:
16CopyLoc[0](Arg0: &mut Staking)
17ImmBorrowField[13](Staking.validators: vector<address>)
18CopyLoc[4](loc1: u64)
19VecImmBorrow(60)
20ReadRef
21StLoc[7](loc4: address)
22CopyLoc[7](loc4: address)
23ImmBorrowLoc[3](loc0: vector<address>)
24Call is_active_validator(address, &vector<address>): bool
25Not
26BrFalse(30)
B4:
27MutBorrowLoc[5](loc2: vector<address>)
28MoveLoc[7](loc4: address)
29VecPushBack(60)
B5:
30MoveLoc[4](loc1: u64)
31LdU64(1)
32Add
33StLoc[4](loc1: u64)
34Branch(11)
B6:
35ImmBorrowLoc[5](loc2: vector<address>)
36VecLen(60)
37LdU64(0)
38Gt
39BrFalse(46)
B7:
40MoveLoc[0](Arg0: &mut Staking)
41MoveLoc[1](Arg1: &mut SuiSystemState)
42MoveLoc[5](loc2: vector<address>)
43MoveLoc[2](Arg2: &mut TxContext)
44Call unstake_validator_pools(&mut Staking, &mut SuiSystemState, vector<address>, &mut TxContext)
45Branch(52)
B8:
46MoveLoc[1](Arg1: &mut SuiSystemState)
47Pop
48MoveLoc[0](Arg0: &mut Staking)
49Pop
50MoveLoc[2](Arg2: &mut TxContext)
51Pop
B9:
52Ret
}
 
public(friend) unstake_validator_pools(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: vector<address>, Arg3: &mut TxContext) {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: Balance<SUI>
L8: loc4: address
B0:
0CopyLoc[3](Arg3: &mut TxContext)
1FreezeRef
2Call tx_context::epoch(&TxContext): u64
3StLoc[4](loc0: u64)
4Call balance::zero<SUI>(): Balance<SUI>
5StLoc[7](loc3: Balance<SUI>)
6ImmBorrowLoc[2](Arg2: vector<address>)
7VecLen(60)
8StLoc[6](loc2: u64)
9LdU64(0)
10StLoc[5](loc1: u64)
B1:
11CopyLoc[5](loc1: u64)
12CopyLoc[6](loc2: u64)
13Lt
14BrFalse(35)
B2:
15Branch(16)
B3:
16ImmBorrowLoc[2](Arg2: vector<address>)
17CopyLoc[5](loc1: u64)
18VecImmBorrow(60)
19ReadRef
20StLoc[8](loc4: address)
21CopyLoc[0](Arg0: &mut Staking)
22CopyLoc[1](Arg1: &mut SuiSystemState)
23MutBorrowLoc[7](loc3: Balance<SUI>)
24MoveLoc[8](loc4: address)
25LdConst[8](u64: 1844..)
26CopyLoc[4](loc0: u64)
27CopyLoc[3](Arg3: &mut TxContext)
28Call do_validator_unstake(&mut Staking, &mut SuiSystemState, &mut Balance<SUI>, address, u64, u64, &mut TxContext): u64
29Pop
30MoveLoc[5](loc1: u64)
31LdU64(1)
32Add
33StLoc[5](loc1: u64)
34Branch(11)
B4:
35MoveLoc[1](Arg1: &mut SuiSystemState)
36Pop
37MoveLoc[3](Arg3: &mut TxContext)
38Pop
39MoveLoc[0](Arg0: &mut Staking)
40MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
41MoveLoc[7](loc3: Balance<SUI>)
42Call vault::deposit<SUI>(&mut Vault<SUI>, Balance<SUI>)
43Ret
}
 
public(friend) unstake_from_validator(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: address, Arg3: u64, Arg4: &mut TxContext) {
L5: loc0: u64
L6: loc1: Balance<SUI>
B0:
0CopyLoc[4](Arg4: &mut TxContext)
1FreezeRef
2Call tx_context::epoch(&TxContext): u64
3StLoc[5](loc0: u64)
4Call balance::zero<SUI>(): Balance<SUI>
5StLoc[6](loc1: Balance<SUI>)
6CopyLoc[0](Arg0: &mut Staking)
7MoveLoc[1](Arg1: &mut SuiSystemState)
8MutBorrowLoc[6](loc1: Balance<SUI>)
9MoveLoc[2](Arg2: address)
10MoveLoc[3](Arg3: u64)
11MoveLoc[5](loc0: u64)
12MoveLoc[4](Arg4: &mut TxContext)
13Call do_validator_unstake(&mut Staking, &mut SuiSystemState, &mut Balance<SUI>, address, u64, u64, &mut TxContext): u64
14Pop
15MoveLoc[0](Arg0: &mut Staking)
16MutBorrowField[1](Staking.sui_vault: Vault<SUI>)
17MoveLoc[6](loc1: Balance<SUI>)
18Call vault::deposit<SUI>(&mut Vault<SUI>, Balance<SUI>)
19Ret
}
 
public(friend) sort_validators(Arg0: &mut Staking, Arg1: vector<address>) {
L2: loc0: u64
L3: loc1: u64
L4: loc2: &address
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[13](Staking.validators: vector<address>)
2VecLen(60)
3StLoc[3](loc1: u64)
4ImmBorrowLoc[1](Arg1: vector<address>)
5VecLen(60)
6CopyLoc[3](loc1: u64)
7Eq
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[0](Arg0: &mut Staking)
11Pop
12LdConst[24](u64: 18)
13Abort
B3:
14LdU64(0)
15StLoc[2](loc0: u64)
B4:
16CopyLoc[2](loc0: u64)
17CopyLoc[3](loc1: u64)
18Lt
19BrFalse(40)
B5:
20Branch(21)
B6:
21CopyLoc[0](Arg0: &mut Staking)
22ImmBorrowField[13](Staking.validators: vector<address>)
23CopyLoc[2](loc0: u64)
24VecImmBorrow(60)
25StLoc[4](loc2: &address)
26ImmBorrowLoc[1](Arg1: vector<address>)
27MoveLoc[4](loc2: &address)
28Call vector::contains<address>(&vector<address>, &address): bool
29BrFalse(31)
B7:
30Branch(35)
B8:
31MoveLoc[0](Arg0: &mut Staking)
32Pop
33LdConst[25](u64: 19)
34Abort
B9:
35MoveLoc[2](loc0: u64)
36LdU64(1)
37Add
38StLoc[2](loc0: u64)
39Branch(16)
B10:
40MoveLoc[1](Arg1: vector<address>)
41MoveLoc[0](Arg0: &mut Staking)
42MutBorrowField[13](Staking.validators: vector<address>)
43WriteRef
44Ret
}
 
stake_user_selected_validators(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: &vector<address>, Arg3: &mut TxContext): Balance<SUI> {
L4: loc0: Balance<SUI>
L5: loc1: address
L6: loc2: vector<Balance<SUI>>
L7: loc3: vector<address>
B0:
0CopyLoc[0](Arg0: &mut Staking)
1MoveLoc[2](Arg2: &vector<address>)
2Call get_user_selected_validators(&mut Staking, &vector<address>): vector<address> * vector<Balance<SUI>> * Balance<SUI>
3StLoc[4](loc0: Balance<SUI>)
4StLoc[6](loc2: vector<Balance<SUI>>)
5StLoc[7](loc3: vector<address>)
B1:
6ImmBorrowLoc[6](loc2: vector<Balance<SUI>>)
7VecLen(14)
8LdU64(0)
9Gt
10BrFalse(23)
B2:
11Branch(12)
B3:
12MutBorrowLoc[7](loc3: vector<address>)
13VecPopBack(60)
14StLoc[5](loc1: address)
15MutBorrowLoc[6](loc2: vector<Balance<SUI>>)
16VecPopBack(14)
17CopyLoc[0](Arg0: &mut Staking)
18CopyLoc[1](Arg1: &mut SuiSystemState)
19MoveLoc[5](loc1: address)
20CopyLoc[3](Arg3: &mut TxContext)
21Call stake_to_validator(Balance<SUI>, &mut Staking, &mut SuiSystemState, address, &mut TxContext)
22Branch(6)
B4:
23MoveLoc[1](Arg1: &mut SuiSystemState)
24Pop
25MoveLoc[0](Arg0: &mut Staking)
26Pop
27MoveLoc[3](Arg3: &mut TxContext)
28Pop
29MoveLoc[6](loc2: vector<Balance<SUI>>)
30VecUnpack(14, 0)
31MoveLoc[4](loc0: Balance<SUI>)
32Ret
}
 
get_user_selected_validators(Arg0: &mut Staking, Arg1: &vector<address>): vector<address> * vector<Balance<SUI>> * Balance<SUI> {
L2: loc0: Balance<SUI>
L3: loc1: address
L4: loc2: Balance<SUI>
L5: loc3: vector<Balance<SUI>>
L6: loc4: vector<address>
B0:
0Call balance::zero<SUI>(): Balance<SUI>
1StLoc[2](loc0: Balance<SUI>)
2VecPack(60, 0)
3StLoc[6](loc4: vector<address>)
4VecPack(14, 0)
5StLoc[5](loc3: vector<Balance<SUI>>)
B1:
6CopyLoc[0](Arg0: &mut Staking)
7ImmBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
8Call vec_map::is_empty<address, Balance<SUI>>(&VecMap<address, Balance<SUI>>): bool
9Not
10BrFalse(43)
B2:
11Branch(12)
B3:
12CopyLoc[0](Arg0: &mut Staking)
13MutBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
14Call vec_map::pop<address, Balance<SUI>>(&mut VecMap<address, Balance<SUI>>): address * Balance<SUI>
15StLoc[4](loc2: Balance<SUI>)
16StLoc[3](loc1: address)
17CopyLoc[3](loc1: address)
18CopyLoc[1](Arg1: &vector<address>)
19Call is_active_validator(address, &vector<address>): bool
20BrFalse(38)
B4:
21ImmBorrowLoc[4](loc2: Balance<SUI>)
22Call balance::value<SUI>(&Balance<SUI>): u64
23LdConst[0](u64: 1000..)
24Ge
25BrFalse(33)
B5:
26MutBorrowLoc[6](loc4: vector<address>)
27MoveLoc[3](loc1: address)
28VecPushBack(60)
29MutBorrowLoc[5](loc3: vector<Balance<SUI>>)
30MoveLoc[4](loc2: Balance<SUI>)
31VecPushBack(14)
32Branch(37)
B6:
33MutBorrowLoc[2](loc0: Balance<SUI>)
34MoveLoc[4](loc2: Balance<SUI>)
35Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
36Pop
B7:
37Branch(42)
B8:
38MutBorrowLoc[2](loc0: Balance<SUI>)
39MoveLoc[4](loc2: Balance<SUI>)
40Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
41Pop
B9:
42Branch(6)
B10:
43MoveLoc[0](Arg0: &mut Staking)
44Pop
45MoveLoc[1](Arg1: &vector<address>)
46Pop
47MoveLoc[6](loc4: vector<address>)
48MoveLoc[5](loc3: vector<Balance<SUI>>)
49MoveLoc[2](loc0: Balance<SUI>)
50Ret
}
 
stake_to_validator(Arg0: Balance<SUI>, Arg1: &mut Staking, Arg2: &mut SuiSystemState, Arg3: address, Arg4: &mut TxContext) {
L5: loc0: u64
L6: loc1: PoolInfo
L7: loc2: &mut PoolInfo
L8: loc3: StakedSui
L9: loc4: ID
B0:
0CopyLoc[1](Arg1: &mut Staking)
1ImmBorrowField[16](Staking.pools: Table<address, PoolInfo>)
2CopyLoc[3](Arg3: address)
3Call table::contains<address, PoolInfo>(&Table<address, PoolInfo>, address): bool
4Not
5BrFalse(21)
B1:
6CopyLoc[4](Arg4: &mut TxContext)
7Call table_queue::empty<StakedSui>(&mut TxContext): TableQueue<StakedSui>
8LdU64(0)
9LdU64(0)
10Pack[1](PoolInfo)
11StLoc[6](loc1: PoolInfo)
12CopyLoc[1](Arg1: &mut Staking)
13MutBorrowField[16](Staking.pools: Table<address, PoolInfo>)
14CopyLoc[3](Arg3: address)
15MoveLoc[6](loc1: PoolInfo)
16Call table::add<address, PoolInfo>(&mut Table<address, PoolInfo>, address, PoolInfo)
17CopyLoc[1](Arg1: &mut Staking)
18MutBorrowField[13](Staking.validators: vector<address>)
19CopyLoc[3](Arg3: address)
20VecPushBack(60)
B2:
21MoveLoc[1](Arg1: &mut Staking)
22MutBorrowField[16](Staking.pools: Table<address, PoolInfo>)
23CopyLoc[3](Arg3: address)
24Call table::borrow_mut<address, PoolInfo>(&mut Table<address, PoolInfo>, address): &mut PoolInfo
25StLoc[7](loc2: &mut PoolInfo)
26ImmBorrowLoc[0](Arg0: Balance<SUI>)
27Call balance::value<SUI>(&Balance<SUI>): u64
28StLoc[5](loc0: u64)
29CopyLoc[7](loc2: &mut PoolInfo)
30ImmBorrowField[18](PoolInfo.total_staked: u64)
31ReadRef
32CopyLoc[5](loc0: u64)
33Add
34CopyLoc[7](loc2: &mut PoolInfo)
35MutBorrowField[18](PoolInfo.total_staked: u64)
36WriteRef
37MoveLoc[2](Arg2: &mut SuiSystemState)
38MoveLoc[0](Arg0: Balance<SUI>)
39CopyLoc[4](Arg4: &mut TxContext)
40Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
41CopyLoc[3](Arg3: address)
42CopyLoc[4](Arg4: &mut TxContext)
43Call sui_system::request_add_stake_non_entry(&mut SuiSystemState, Coin<SUI>, address, &mut TxContext): StakedSui
44StLoc[8](loc3: StakedSui)
45ImmBorrowLoc[8](loc3: StakedSui)
46Call object::id<StakedSui>(&StakedSui): ID
47StLoc[9](loc4: ID)
48MoveLoc[7](loc2: &mut PoolInfo)
49MutBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
50MoveLoc[8](loc3: StakedSui)
51Call table_queue::push_back<StakedSui>(&mut TableQueue<StakedSui>, StakedSui)
52MoveLoc[9](loc4: ID)
53MoveLoc[4](Arg4: &mut TxContext)
54FreezeRef
55Call tx_context::epoch(&TxContext): u64
56MoveLoc[5](loc0: u64)
57MoveLoc[3](Arg3: address)
58Pack[8](SystemStaked)
59Call event::emit<SystemStaked>(SystemStaked)
60Ret
}
 
is_active_validator(Arg0: address, Arg1: &vector<address>): bool {
B0:
0MoveLoc[1](Arg1: &vector<address>)
1ImmBorrowLoc[0](Arg0: address)
2Call vector::contains<address>(&vector<address>, &address): bool
3Ret
}
 
calculate_validator_pool_rewards_increase(Arg0: &mut SuiSystemState, Arg1: &mut PoolInfo, Arg2: u64): u64 {
L3: loc0: u64
L4: loc1: u64
L5: loc2: u64
L6: loc3: u64
L7: loc4: &StakedSui
L8: loc5: u64
B0:
0CopyLoc[1](Arg1: &mut PoolInfo)
1ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
2Call table_queue::length<StakedSui>(&TableQueue<StakedSui>): u64
3LdU64(0)
4Eq
5BrFalse(12)
B1:
6MoveLoc[0](Arg0: &mut SuiSystemState)
7Pop
8MoveLoc[1](Arg1: &mut PoolInfo)
9Pop
10LdU64(0)
11Ret
B2:
12LdU64(0)
13StLoc[5](loc2: u64)
14CopyLoc[1](Arg1: &mut PoolInfo)
15ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
16Call table_queue::head<StakedSui>(&TableQueue<StakedSui>): u64
17StLoc[3](loc0: u64)
18CopyLoc[1](Arg1: &mut PoolInfo)
19ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
20Call table_queue::tail<StakedSui>(&TableQueue<StakedSui>): u64
21StLoc[8](loc5: u64)
22MoveLoc[3](loc0: u64)
23StLoc[4](loc1: u64)
B3:
24CopyLoc[4](loc1: u64)
25CopyLoc[8](loc5: u64)
26Lt
27BrFalse(46)
B4:
28Branch(29)
B5:
29CopyLoc[1](Arg1: &mut PoolInfo)
30ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
31CopyLoc[4](loc1: u64)
32Call table_queue::borrow<StakedSui>(&TableQueue<StakedSui>, u64): &StakedSui
33StLoc[7](loc4: &StakedSui)
34MoveLoc[5](loc2: u64)
35CopyLoc[0](Arg0: &mut SuiSystemState)
36MoveLoc[7](loc4: &StakedSui)
37CopyLoc[2](Arg2: u64)
38Call calculate_staked_sui_rewards(&mut SuiSystemState, &StakedSui, u64): u64
39Add
40StLoc[5](loc2: u64)
41MoveLoc[4](loc1: u64)
42LdU64(1)
43Add
44StLoc[4](loc1: u64)
45Branch(24)
B6:
46MoveLoc[0](Arg0: &mut SuiSystemState)
47Pop
48LdU64(0)
49StLoc[6](loc3: u64)
50CopyLoc[5](loc2: u64)
51CopyLoc[1](Arg1: &mut PoolInfo)
52ImmBorrowField[20](PoolInfo.rewards: u64)
53ReadRef
54Gt
55BrFalse(67)
B7:
56CopyLoc[5](loc2: u64)
57CopyLoc[1](Arg1: &mut PoolInfo)
58ImmBorrowField[20](PoolInfo.rewards: u64)
59ReadRef
60Sub
61StLoc[6](loc3: u64)
62MoveLoc[5](loc2: u64)
63MoveLoc[1](Arg1: &mut PoolInfo)
64MutBorrowField[20](PoolInfo.rewards: u64)
65WriteRef
66Branch(69)
B8:
67MoveLoc[1](Arg1: &mut PoolInfo)
68Pop
B9:
69MoveLoc[6](loc3: u64)
70Ret
}
 
calculate_staked_sui_rewards(Arg0: &mut SuiSystemState, Arg1: &StakedSui, Arg2: u64): u64 {
L3: loc0: ID
L4: loc1: u64
L5: loc2: u64
B0:
0CopyLoc[1](Arg1: &StakedSui)
1Call staking_pool::pool_id(&StakedSui): ID
2StLoc[3](loc0: ID)
3CopyLoc[1](Arg1: &StakedSui)
4Call staking_pool::staked_sui_amount(&StakedSui): u64
5StLoc[4](loc1: u64)
6MoveLoc[1](Arg1: &StakedSui)
7Call staking_pool::stake_activation_epoch(&StakedSui): u64
8StLoc[5](loc2: u64)
9MoveLoc[0](Arg0: &mut SuiSystemState)
10MoveLoc[3](loc0: ID)
11MoveLoc[4](loc1: u64)
12MoveLoc[5](loc2: u64)
13MoveLoc[2](Arg2: u64)
14Call util::calculate_rewards(&mut SuiSystemState, ID, u64, u64, u64): u64
15Ret
}
 
do_validator_unstake(Arg0: &mut Staking, Arg1: &mut SuiSystemState, Arg2: &mut Balance<SUI>, Arg3: address, Arg4: u64, Arg5: u64, Arg6: &mut TxContext): u64 {
L7: loc0: bool
L8: loc1: StakedSui
L9: loc2: u64
L10: loc3: u64
L11: loc4: &mut PoolInfo
L12: loc5: bool
L13: loc6: &StakedSui
L14: loc7: u64
L15: loc8: StakedSui
L16: loc9: u64
L17: loc10: u64
L18: loc11: u64
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[16](Staking.pools: Table<address, PoolInfo>)
2CopyLoc[3](Arg3: address)
3Call table::contains<address, PoolInfo>(&Table<address, PoolInfo>, address): bool
4Not
5BrFalse(16)
B1:
6MoveLoc[1](Arg1: &mut SuiSystemState)
7Pop
8MoveLoc[2](Arg2: &mut Balance<SUI>)
9Pop
10MoveLoc[0](Arg0: &mut Staking)
11Pop
12MoveLoc[6](Arg6: &mut TxContext)
13Pop
14MoveLoc[4](Arg4: u64)
15Ret
B2:
16CopyLoc[4](Arg4: u64)
17StLoc[10](loc3: u64)
18LdU64(0)
19StLoc[14](loc7: u64)
20CopyLoc[0](Arg0: &mut Staking)
21MutBorrowField[16](Staking.pools: Table<address, PoolInfo>)
22CopyLoc[3](Arg3: address)
23Call table::borrow_mut<address, PoolInfo>(&mut Table<address, PoolInfo>, address): &mut PoolInfo
24StLoc[11](loc4: &mut PoolInfo)
B3:
25CopyLoc[4](Arg4: u64)
26LdU64(0)
27Gt
28BrFalse(37)
B4:
29Branch(30)
B5:
30CopyLoc[11](loc4: &mut PoolInfo)
31ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
32Call table_queue::length<StakedSui>(&TableQueue<StakedSui>): u64
33LdU64(0)
34Gt
35StLoc[7](loc0: bool)
36Branch(39)
B6:
37LdFalse
38StLoc[7](loc0: bool)
B7:
39MoveLoc[7](loc0: bool)
40BrFalse(124)
B8:
41CopyLoc[11](loc4: &mut PoolInfo)
42ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
43Call table_queue::borrow_front<StakedSui>(&TableQueue<StakedSui>): &StakedSui
44StLoc[13](loc6: &StakedSui)
45CopyLoc[1](Arg1: &mut SuiSystemState)
46MoveLoc[13](loc6: &StakedSui)
47CopyLoc[4](Arg4: u64)
48CopyLoc[5](Arg5: u64)
49Call get_split_amount(&mut SuiSystemState, &StakedSui, u64, u64): u64 * u64
50StLoc[16](loc9: u64)
51LdU64(0)
52Gt
53BrFalse(62)
B9:
54CopyLoc[11](loc4: &mut PoolInfo)
55MutBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
56Call table_queue::borrow_front_mut<StakedSui>(&mut TableQueue<StakedSui>): &mut StakedSui
57MoveLoc[16](loc9: u64)
58CopyLoc[6](Arg6: &mut TxContext)
59Call staking_pool::split(&mut StakedSui, u64, &mut TxContext): StakedSui
60StLoc[8](loc1: StakedSui)
61Branch(66)
B10:
62CopyLoc[11](loc4: &mut PoolInfo)
63MutBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
64Call table_queue::pop_front<StakedSui>(&mut TableQueue<StakedSui>): StakedSui
65StLoc[8](loc1: StakedSui)
B11:
66MoveLoc[8](loc1: StakedSui)
67StLoc[15](loc8: StakedSui)
68CopyLoc[1](Arg1: &mut SuiSystemState)
69MoveLoc[15](loc8: StakedSui)
70CopyLoc[2](Arg2: &mut Balance<SUI>)
71CopyLoc[6](Arg6: &mut TxContext)
72Call withdraw_staked_sui(&mut SuiSystemState, StakedSui, &mut Balance<SUI>, &mut TxContext): u64 * u64
73StLoc[18](loc11: u64)
74StLoc[17](loc10: u64)
75MoveLoc[14](loc7: u64)
76CopyLoc[17](loc10: u64)
77Add
78CopyLoc[18](loc11: u64)
79Add
80StLoc[14](loc7: u64)
81CopyLoc[17](loc10: u64)
82CopyLoc[18](loc11: u64)
83Add
84CopyLoc[4](Arg4: u64)
85Le
86BrFalse(94)
B12:
87MoveLoc[4](Arg4: u64)
88CopyLoc[17](loc10: u64)
89Sub
90CopyLoc[18](loc11: u64)
91Sub
92StLoc[4](Arg4: u64)
93Branch(96)
B13:
94LdU64(0)
95StLoc[4](Arg4: u64)
B14:
96CopyLoc[11](loc4: &mut PoolInfo)
97ImmBorrowField[18](PoolInfo.total_staked: u64)
98ReadRef
99MoveLoc[17](loc10: u64)
100Sub
101CopyLoc[11](loc4: &mut PoolInfo)
102MutBorrowField[18](PoolInfo.total_staked: u64)
103WriteRef
104CopyLoc[11](loc4: &mut PoolInfo)
105ImmBorrowField[20](PoolInfo.rewards: u64)
106ReadRef
107CopyLoc[18](loc11: u64)
108Ge
109BrFalse(119)
B15:
110CopyLoc[11](loc4: &mut PoolInfo)
111ImmBorrowField[20](PoolInfo.rewards: u64)
112ReadRef
113MoveLoc[18](loc11: u64)
114Sub
115CopyLoc[11](loc4: &mut PoolInfo)
116MutBorrowField[20](PoolInfo.rewards: u64)
117WriteRef
118Branch(123)
B16:
119LdU64(0)
120CopyLoc[11](loc4: &mut PoolInfo)
121MutBorrowField[20](PoolInfo.rewards: u64)
122WriteRef
B17:
123Branch(25)
B18:
124MoveLoc[1](Arg1: &mut SuiSystemState)
125Pop
126MoveLoc[2](Arg2: &mut Balance<SUI>)
127Pop
128MoveLoc[6](Arg6: &mut TxContext)
129Pop
130MoveLoc[11](loc4: &mut PoolInfo)
131ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
132Call table_queue::is_empty<StakedSui>(&TableQueue<StakedSui>): bool
133StLoc[12](loc5: bool)
134CopyLoc[12](loc5: bool)
135BrFalse(159)
B19:
136CopyLoc[0](Arg0: &mut Staking)
137MutBorrowField[16](Staking.pools: Table<address, PoolInfo>)
138CopyLoc[3](Arg3: address)
139Call table::remove<address, PoolInfo>(&mut Table<address, PoolInfo>, address): PoolInfo
140Unpack[1](PoolInfo)
141Pop
142Pop
143Call table_queue::destroy_empty<StakedSui>(TableQueue<StakedSui>)
144CopyLoc[0](Arg0: &mut Staking)
145ImmBorrowField[13](Staking.validators: vector<address>)
146ImmBorrowLoc[3](Arg3: address)
147Call vector::index_of<address>(&vector<address>, &address): bool * u64
148StLoc[9](loc2: u64)
149BrFalse(156)
B20:
150MoveLoc[0](Arg0: &mut Staking)
151MutBorrowField[13](Staking.validators: vector<address>)
152MoveLoc[9](loc2: u64)
153Call vector::remove<address>(&mut vector<address>, u64): address
154Pop
155Branch(158)
B21:
156MoveLoc[0](Arg0: &mut Staking)
157Pop
B22:
158Branch(161)
B23:
159MoveLoc[0](Arg0: &mut Staking)
160Pop
B24:
161MoveLoc[10](loc3: u64)
162CopyLoc[4](Arg4: u64)
163Neq
164BrFalse(171)
B25:
165MoveLoc[3](Arg3: address)
166MoveLoc[5](Arg5: u64)
167MoveLoc[14](loc7: u64)
168MoveLoc[12](loc5: bool)
169Pack[10](PoolSystemUnstaked)
170Call event::emit<PoolSystemUnstaked>(PoolSystemUnstaked)
B26:
171MoveLoc[4](Arg4: u64)
172Ret
}
 
get_split_amount(Arg0: &mut SuiSystemState, Arg1: &StakedSui, Arg2: u64, Arg3: u64): u64 * u64 {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
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: u64
L17: loc13: u64
B0:
0CopyLoc[1](Arg1: &StakedSui)
1Call staking_pool::staked_sui_amount(&StakedSui): u64
2StLoc[14](loc10: u64)
3MoveLoc[0](Arg0: &mut SuiSystemState)
4MoveLoc[1](Arg1: &StakedSui)
5MoveLoc[3](Arg3: u64)
6Call calculate_staked_sui_rewards(&mut SuiSystemState, &StakedSui, u64): u64
7StLoc[15](loc11: u64)
8CopyLoc[14](loc10: u64)
9MoveLoc[15](loc11: u64)
10Add
11StLoc[16](loc12: u64)
12CopyLoc[16](loc12: u64)
13CopyLoc[2](Arg2: u64)
14Le
15BrFalse(21)
B1:
16LdU64(0)
17MoveLoc[14](loc10: u64)
18StLoc[12](loc8: u64)
19StLoc[11](loc7: u64)
20Branch(90)
B2:
21MoveLoc[2](Arg2: u64)
22CopyLoc[14](loc10: u64)
23MoveLoc[16](loc12: u64)
24Call util::mul_div(u64, u64, u64): u64
25LdU64(1)
26Add
27StLoc[17](loc13: u64)
28CopyLoc[14](loc10: u64)
29CopyLoc[17](loc13: u64)
30Ge
31BrFalse(37)
B3:
32CopyLoc[14](loc10: u64)
33CopyLoc[17](loc13: u64)
34Sub
35StLoc[4](loc0: u64)
36Branch(41)
B4:
37CopyLoc[14](loc10: u64)
38StLoc[17](loc13: u64)
39LdU64(0)
40StLoc[4](loc0: u64)
B5:
41MoveLoc[4](loc0: u64)
42StLoc[13](loc9: u64)
43CopyLoc[17](loc13: u64)
44LdConst[0](u64: 1000..)
45Ge
46BrFalse(65)
B6:
47CopyLoc[13](loc9: u64)
48LdConst[0](u64: 1000..)
49Ge
50BrFalse(56)
B7:
51MoveLoc[13](loc9: u64)
52MoveLoc[17](loc13: u64)
53StLoc[6](loc2: u64)
54StLoc[5](loc1: u64)
55Branch(60)
B8:
56LdU64(0)
57MoveLoc[14](loc10: u64)
58StLoc[6](loc2: u64)
59StLoc[5](loc1: u64)
B9:
60MoveLoc[5](loc1: u64)
61MoveLoc[6](loc2: u64)
62StLoc[10](loc6: u64)
63StLoc[9](loc5: u64)
64Branch(86)
B10:
65CopyLoc[14](loc10: u64)
66LdU64(2)
67LdConst[0](u64: 1000..)
68Mul
69Ge
70BrFalse(78)
B11:
71MoveLoc[14](loc10: u64)
72LdConst[0](u64: 1000..)
73Sub
74LdConst[0](u64: 1000..)
75StLoc[8](loc4: u64)
76StLoc[7](loc3: u64)
77Branch(82)
B12:
78LdU64(0)
79MoveLoc[14](loc10: u64)
80StLoc[8](loc4: u64)
81StLoc[7](loc3: u64)
B13:
82MoveLoc[7](loc3: u64)
83MoveLoc[8](loc4: u64)
84StLoc[10](loc6: u64)
85StLoc[9](loc5: u64)
B14:
86MoveLoc[9](loc5: u64)
87MoveLoc[10](loc6: u64)
88StLoc[12](loc8: u64)
89StLoc[11](loc7: u64)
B15:
90MoveLoc[11](loc7: u64)
91MoveLoc[12](loc8: u64)
92Ret
}
 
withdraw_staked_sui(Arg0: &mut SuiSystemState, Arg1: StakedSui, Arg2: &mut Balance<SUI>, Arg3: &mut TxContext): u64 * u64 {
L4: loc0: u64
L5: loc1: u64
L6: loc2: Balance<SUI>
B0:
0ImmBorrowLoc[1](Arg1: StakedSui)
1Call staking_pool::staked_sui_amount(&StakedSui): u64
2StLoc[4](loc0: u64)
3CopyLoc[0](Arg0: &mut SuiSystemState)
4ImmBorrowLoc[1](Arg1: StakedSui)
5CopyLoc[3](Arg3: &mut TxContext)
6FreezeRef
7Call tx_context::epoch(&TxContext): u64
8Call calculate_staked_sui_rewards(&mut SuiSystemState, &StakedSui, u64): u64
9StLoc[5](loc1: u64)
10MoveLoc[0](Arg0: &mut SuiSystemState)
11MoveLoc[1](Arg1: StakedSui)
12MoveLoc[3](Arg3: &mut TxContext)
13Call sui_system::request_withdraw_stake_non_entry(&mut SuiSystemState, StakedSui, &mut TxContext): Balance<SUI>
14StLoc[6](loc2: Balance<SUI>)
15ImmBorrowLoc[6](loc2: Balance<SUI>)
16Call balance::value<SUI>(&Balance<SUI>): u64
17CopyLoc[4](loc0: u64)
18CopyLoc[5](loc1: u64)
19Add
20Eq
21BrFalse(23)
B1:
22Branch(27)
B2:
23MoveLoc[2](Arg2: &mut Balance<SUI>)
24Pop
25LdConst[12](u64: 2)
26Abort
B3:
27MoveLoc[2](Arg2: &mut Balance<SUI>)
28MoveLoc[6](loc2: Balance<SUI>)
29Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
30Pop
31MoveLoc[4](loc0: u64)
32MoveLoc[5](loc1: u64)
33Ret
}
 
public(friend) collect_rewards_fee(Arg0: &mut Staking, Arg1: address, Arg2: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
 
public(friend) collect_rewards_fee_v2(Arg0: &mut SuiSystemState, Arg1: &mut Staking, Arg2: address, Arg3: &mut TxContext) {
L4: loc0: Balance<SUI>
L5: loc1: u64
L6: loc2: u64
B0:
0CopyLoc[1](Arg1: &mut Staking)
1MutBorrowField[21](Staking.protocol_sui_vault: Vault<SUI>)
2CopyLoc[1](Arg1: &mut Staking)
3ImmBorrowField[17](Staking.uncollected_protocol_fees: u64)
4ReadRef
5Call vault::withdraw_max<SUI>(&mut Vault<SUI>, u64): Balance<SUI> * u64
6StLoc[5](loc1: u64)
7StLoc[4](loc0: Balance<SUI>)
8MutBorrowLoc[4](loc0: Balance<SUI>)
9MoveLoc[0](Arg0: &mut SuiSystemState)
10CopyLoc[1](Arg1: &mut Staking)
11MoveLoc[5](loc1: u64)
12LdFalse
13CopyLoc[3](Arg3: &mut TxContext)
14Call withdraw_sui(&mut SuiSystemState, &mut Staking, u64, bool, &mut TxContext): Balance<SUI>
15Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
16Pop
17CopyLoc[1](Arg1: &mut Staking)
18ImmBorrowField[22](Staking.total_protocol_fees: u64)
19ReadRef
20CopyLoc[1](Arg1: &mut Staking)
21ImmBorrowField[17](Staking.uncollected_protocol_fees: u64)
22ReadRef
23Add
24CopyLoc[1](Arg1: &mut Staking)
25MutBorrowField[22](Staking.total_protocol_fees: u64)
26WriteRef
27LdU64(0)
28MoveLoc[1](Arg1: &mut Staking)
29MutBorrowField[17](Staking.uncollected_protocol_fees: u64)
30WriteRef
31ImmBorrowLoc[4](loc0: Balance<SUI>)
32Call balance::value<SUI>(&Balance<SUI>): u64
33StLoc[6](loc2: u64)
34MoveLoc[4](loc0: Balance<SUI>)
35MoveLoc[3](Arg3: &mut TxContext)
36Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
37CopyLoc[2](Arg2: address)
38Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
39MoveLoc[2](Arg2: address)
40MoveLoc[6](loc2: u64)
41Pack[12](RewardsFeeCollected)
42Call event::emit<RewardsFeeCollected>(RewardsFeeCollected)
43Ret
}
 
public(friend) collect_service_fee(Arg0: &mut Staking, Arg1: address, Arg2: &mut TxContext) {
L3: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[9](Staking.service_sui_vault: Vault<SUI>)
2Call vault::vault_amount<SUI>(&Vault<SUI>): u64
3StLoc[3](loc0: u64)
4MoveLoc[0](Arg0: &mut Staking)
5MutBorrowField[9](Staking.service_sui_vault: Vault<SUI>)
6CopyLoc[3](loc0: u64)
7Call vault::withdraw<SUI>(&mut Vault<SUI>, u64): Balance<SUI>
8MoveLoc[2](Arg2: &mut TxContext)
9Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
10CopyLoc[1](Arg1: address)
11Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
12MoveLoc[1](Arg1: address)
13MoveLoc[3](loc0: u64)
14Pack[13](ServiceFeeCollected)
15Call event::emit<ServiceFeeCollected>(ServiceFeeCollected)
16Ret
}
 
public get_stsui_by_sui(Arg0: &Staking, Arg1: u64): u64 {
L2: loc0: bool
L3: loc1: u64
B0:
0CopyLoc[0](Arg0: &Staking)
1Call get_total_sui(&Staking): u64
2StLoc[3](loc1: u64)
3CopyLoc[3](loc1: u64)
4LdU64(0)
5Eq
6BrFalse(10)
B1:
7LdTrue
8StLoc[2](loc0: bool)
9Branch(16)
B2:
10CopyLoc[0](Arg0: &Staking)
11ImmBorrowField[0](Staking.stsui_supply: u64)
12ReadRef
13LdU64(0)
14Eq
15StLoc[2](loc0: bool)
B3:
16MoveLoc[2](loc0: bool)
17BrFalse(22)
B4:
18MoveLoc[0](Arg0: &Staking)
19Pop
20MoveLoc[1](Arg1: u64)
21Ret
B5:
22MoveLoc[0](Arg0: &Staking)
23ImmBorrowField[0](Staking.stsui_supply: u64)
24ReadRef
25CastU128
26MoveLoc[1](Arg1: u64)
27CastU128
28Mul
29MoveLoc[3](loc1: u64)
30CastU128
31Div
32CastU64
33Ret
}
 
public get_sui_by_stsui(Arg0: &Staking, Arg1: u64): u64 {
L2: loc0: bool
L3: loc1: u64
B0:
0CopyLoc[0](Arg0: &Staking)
1Call get_total_sui(&Staking): u64
2StLoc[3](loc1: u64)
3CopyLoc[3](loc1: u64)
4LdU64(0)
5Eq
6BrFalse(10)
B1:
7LdTrue
8StLoc[2](loc0: bool)
9Branch(16)
B2:
10CopyLoc[0](Arg0: &Staking)
11ImmBorrowField[0](Staking.stsui_supply: u64)
12ReadRef
13LdU64(0)
14Eq
15StLoc[2](loc0: bool)
B3:
16MoveLoc[2](loc0: bool)
17BrFalse(22)
B4:
18MoveLoc[0](Arg0: &Staking)
19Pop
20MoveLoc[1](Arg1: u64)
21Ret
B5:
22MoveLoc[3](loc1: u64)
23CastU128
24MoveLoc[1](Arg1: u64)
25CastU128
26Mul
27MoveLoc[0](Arg0: &Staking)
28ImmBorrowField[0](Staking.stsui_supply: u64)
29ReadRef
30CastU128
31Div
32CastU64
33Ret
}
 
public get_exchange_rate(Arg0: &Staking): u64 {
L1: loc0: bool
L2: loc1: u64
B0:
0CopyLoc[0](Arg0: &Staking)
1Call get_total_sui(&Staking): u64
2StLoc[2](loc1: u64)
3CopyLoc[2](loc1: u64)
4LdU64(0)
5Eq
6BrFalse(10)
B1:
7LdTrue
8StLoc[1](loc0: bool)
9Branch(16)
B2:
10CopyLoc[0](Arg0: &Staking)
11ImmBorrowField[0](Staking.stsui_supply: u64)
12ReadRef
13LdU64(0)
14Eq
15StLoc[1](loc0: bool)
B3:
16MoveLoc[1](loc0: bool)
17BrFalse(22)
B4:
18MoveLoc[0](Arg0: &Staking)
19Pop
20LdConst[2](u64: 1000..)
21Ret
B5:
22MoveLoc[2](loc1: u64)
23CastU128
24LdConst[2](u64: 1000..)
25CastU128
26Mul
27MoveLoc[0](Arg0: &Staking)
28ImmBorrowField[0](Staking.stsui_supply: u64)
29ReadRef
30CastU128
31Div
32CastU64
33Ret
}
 
public get_total_sui(Arg0: &Staking): u64 {
B0:
0CopyLoc[0](Arg0: &Staking)
1ImmBorrowField[5](Staking.total_staked: u64)
2ReadRef
3CopyLoc[0](Arg0: &Staking)
4ImmBorrowField[2](Staking.total_rewards: u64)
5ReadRef
6Add
7CopyLoc[0](Arg0: &Staking)
8ImmBorrowField[22](Staking.total_protocol_fees: u64)
9ReadRef
10Sub
11CopyLoc[0](Arg0: &Staking)
12ImmBorrowField[17](Staking.uncollected_protocol_fees: u64)
13ReadRef
14Sub
15MoveLoc[0](Arg0: &Staking)
16ImmBorrowField[10](Staking.total_unstaked: u64)
17ReadRef
18Sub
19Ret
}
 
public get_total_sui_cap(Arg0: &Staking): u64 {
B0:
0CopyLoc[0](Arg0: &Staking)
1Call get_total_sui(&Staking): u64
2MoveLoc[0](Arg0: &Staking)
3ImmBorrowField[11](Staking.unclaimed_sui_amount: u64)
4ReadRef
5Add
6Ret
}
 
public get_version(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[14](Staking.version: u64)
2ReadRef
3Ret
}
 
public get_config(Arg0: &Staking): &StakingConfig {
B0:
0CopyLoc[0](Arg0: &Staking)
1Call assert_version(&Staking)
2MoveLoc[0](Arg0: &Staking)
3ImmBorrowField[8](Staking.config: StakingConfig)
4Ret
}
 
public get_config_mut(Arg0: &mut Staking): &mut StakingConfig {
B0:
0CopyLoc[0](Arg0: &mut Staking)
1FreezeRef
2Call assert_version(&Staking)
3MoveLoc[0](Arg0: &mut Staking)
4MutBorrowField[8](Staking.config: StakingConfig)
5Ret
}
 
public get_total_staked(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[5](Staking.total_staked: u64)
2ReadRef
3Ret
}
 
public get_total_unstaked(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[10](Staking.total_unstaked: u64)
2ReadRef
3Ret
}
 
public get_total_rewards(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[2](Staking.total_rewards: u64)
2ReadRef
3Ret
}
 
public get_stsui_supply(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[0](Staking.stsui_supply: u64)
2ReadRef
3Ret
}
 
public get_sui_vault_amount(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[1](Staking.sui_vault: Vault<SUI>)
2Call vault::vault_amount<SUI>(&Vault<SUI>): u64
3Ret
}
 
public get_protocol_sui_vault_amount(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[21](Staking.protocol_sui_vault: Vault<SUI>)
2Call vault::vault_amount<SUI>(&Vault<SUI>): u64
3Ret
}
 
public get_service_sui_vault_amount(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[9](Staking.service_sui_vault: Vault<SUI>)
2Call vault::vault_amount<SUI>(&Vault<SUI>): u64
3Ret
}
 
public get_total_protocol_fees(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[22](Staking.total_protocol_fees: u64)
2ReadRef
3Ret
}
 
public get_uncollected_protocol_fees(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[17](Staking.uncollected_protocol_fees: u64)
2ReadRef
3Ret
}
 
public get_unclaimed_sui_amount(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[11](Staking.unclaimed_sui_amount: u64)
2ReadRef
3Ret
}
 
public(friend) toggle_stake(Arg0: &mut Staking, Arg1: bool) {
B0:
0MoveLoc[1](Arg1: bool)
1MoveLoc[0](Arg0: &mut Staking)
2MutBorrowField[3](Staking.pause_stake: bool)
3WriteRef
4Ret
}
 
public(friend) toggle_unstake(Arg0: &mut Staking, Arg1: bool) {
B0:
0MoveLoc[1](Arg1: bool)
1MoveLoc[0](Arg0: &mut Staking)
2MutBorrowField[7](Staking.pause_unstake: bool)
3WriteRef
4Ret
}
 
public(friend) toggle_claim(Arg0: &mut Staking, Arg1: bool) {
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[23](Staking.id: UID)
2LdConst[9](vector<u8>: "pau..)
3Call dynamic_field::exists_with_type<vector<u8>, bool>(&UID, vector<u8>): bool
4Not
5BrFalse(12)
B1:
6MoveLoc[0](Arg0: &mut Staking)
7MutBorrowField[23](Staking.id: UID)
8LdConst[9](vector<u8>: "pau..)
9MoveLoc[1](Arg1: bool)
10Call dynamic_field::add<vector<u8>, bool>(&mut UID, vector<u8>, bool)
11Branch(18)
B2:
12MoveLoc[1](Arg1: bool)
13MoveLoc[0](Arg0: &mut Staking)
14MutBorrowField[23](Staking.id: UID)
15LdConst[9](vector<u8>: "pau..)
16Call dynamic_field::borrow_mut<vector<u8>, bool>(&mut UID, vector<u8>): &mut bool
17WriteRef
B3:
18Ret
}
 
public query_pause_claim(Arg0: &Staking): bool {
B0:
0CopyLoc[0](Arg0: &Staking)
1ImmBorrowField[23](Staking.id: UID)
2LdConst[9](vector<u8>: "pau..)
3Call dynamic_field::exists_with_type<vector<u8>, bool>(&UID, vector<u8>): bool
4BrFalse(11)
B1:
5MoveLoc[0](Arg0: &Staking)
6ImmBorrowField[23](Staking.id: UID)
7LdConst[9](vector<u8>: "pau..)
8Call dynamic_field::borrow<vector<u8>, bool>(&UID, vector<u8>): &bool
9ReadRef
10Ret
B2:
11MoveLoc[0](Arg0: &Staking)
12Pop
13LdFalse
14Ret
}
 
public get_staked_validators(Arg0: &Staking): vector<address> {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[13](Staking.validators: vector<address>)
2ReadRef
3Ret
}
 
public get_cached_validator_number(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
2Call vec_map::size<address, Balance<SUI>>(&VecMap<address, Balance<SUI>>): u64
3Ret
}
 
public get_staked_validator(Arg0: &Staking, Arg1: address): bool {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[13](Staking.validators: vector<address>)
2ImmBorrowLoc[1](Arg1: address)
3Call vector::contains<address>(&vector<address>, &address): bool
4Ret
}
 
public get_validator_staked_info(Arg0: &Staking): vector<ValidatorStakedInfo> {
L1: loc0: u64
L2: loc1: u64
L3: loc2: &PoolInfo
L4: loc3: vector<ValidatorStakedInfo>
L5: loc4: address
B0:
0VecPack(46, 0)
1StLoc[4](loc3: vector<ValidatorStakedInfo>)
2CopyLoc[0](Arg0: &Staking)
3ImmBorrowField[13](Staking.validators: vector<address>)
4VecLen(60)
5StLoc[2](loc1: u64)
6LdU64(0)
7StLoc[1](loc0: u64)
B1:
8CopyLoc[1](loc0: u64)
9CopyLoc[2](loc1: u64)
10Lt
11BrFalse(42)
B2:
12Branch(13)
B3:
13CopyLoc[0](Arg0: &Staking)
14ImmBorrowField[13](Staking.validators: vector<address>)
15CopyLoc[1](loc0: u64)
16VecImmBorrow(60)
17ReadRef
18StLoc[5](loc4: address)
19MoveLoc[1](loc0: u64)
20LdU64(1)
21Add
22StLoc[1](loc0: u64)
23CopyLoc[0](Arg0: &Staking)
24ImmBorrowField[16](Staking.pools: Table<address, PoolInfo>)
25CopyLoc[5](loc4: address)
26Call table::borrow<address, PoolInfo>(&Table<address, PoolInfo>, address): &PoolInfo
27StLoc[3](loc2: &PoolInfo)
28MutBorrowLoc[4](loc3: vector<ValidatorStakedInfo>)
29MoveLoc[5](loc4: address)
30CopyLoc[3](loc2: &PoolInfo)
31ImmBorrowField[18](PoolInfo.total_staked: u64)
32ReadRef
33CopyLoc[3](loc2: &PoolInfo)
34ImmBorrowField[20](PoolInfo.rewards: u64)
35ReadRef
36MoveLoc[3](loc2: &PoolInfo)
37ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
38Call table_queue::length<StakedSui>(&TableQueue<StakedSui>): u64
39Pack[17](ValidatorStakedInfo)
40VecPushBack(46)
41Branch(8)
B4:
42MoveLoc[0](Arg0: &Staking)
43Pop
44MoveLoc[4](loc3: vector<ValidatorStakedInfo>)
45Ret
}
 
public get_all_current_validator_staked_info(Arg0: &Staking, Arg1: &mut SuiSystemState, Arg2: &TxContext): vector<ValidatorStakedInfo> {
L3: loc0: u64
L4: loc1: u64
L5: loc2: vector<ValidatorStakedInfo>
L6: loc3: address
L7: loc4: vector<address>
B0:
0VecPack(46, 0)
1StLoc[5](loc2: vector<ValidatorStakedInfo>)
2CopyLoc[0](Arg0: &Staking)
3ImmBorrowField[13](Staking.validators: vector<address>)
4ReadRef
5StLoc[7](loc4: vector<address>)
6CopyLoc[0](Arg0: &Staking)
7ImmBorrowField[13](Staking.validators: vector<address>)
8VecLen(60)
9StLoc[4](loc1: u64)
10LdU64(0)
11StLoc[3](loc0: u64)
B1:
12CopyLoc[3](loc0: u64)
13CopyLoc[4](loc1: u64)
14Lt
15BrFalse(34)
B2:
16Branch(17)
B3:
17ImmBorrowLoc[7](loc4: vector<address>)
18CopyLoc[3](loc0: u64)
19VecImmBorrow(60)
20ReadRef
21StLoc[6](loc3: address)
22MoveLoc[3](loc0: u64)
23LdU64(1)
24Add
25StLoc[3](loc0: u64)
26MutBorrowLoc[5](loc2: vector<ValidatorStakedInfo>)
27CopyLoc[0](Arg0: &Staking)
28CopyLoc[1](Arg1: &mut SuiSystemState)
29MoveLoc[6](loc3: address)
30CopyLoc[2](Arg2: &TxContext)
31Call get_current_validator_staked_info(&Staking, &mut SuiSystemState, address, &TxContext): ValidatorStakedInfo
32VecPushBack(46)
33Branch(12)
B4:
34MoveLoc[1](Arg1: &mut SuiSystemState)
35Pop
36MoveLoc[0](Arg0: &Staking)
37Pop
38MoveLoc[2](Arg2: &TxContext)
39Pop
40MoveLoc[5](loc2: vector<ValidatorStakedInfo>)
41Ret
}
 
public get_current_validator_staked_info(Arg0: &Staking, Arg1: &mut SuiSystemState, Arg2: address, Arg3: &TxContext): ValidatorStakedInfo {
L4: loc0: u64
L5: loc1: &PoolInfo
L6: loc2: ValidatorStakedInfo
L7: loc3: &StakedSui
L8: loc4: u64
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[16](Staking.pools: Table<address, PoolInfo>)
2CopyLoc[2](Arg2: address)
3Call table::borrow<address, PoolInfo>(&Table<address, PoolInfo>, address): &PoolInfo
4StLoc[5](loc1: &PoolInfo)
5MoveLoc[2](Arg2: address)
6LdU64(0)
7LdU64(0)
8CopyLoc[5](loc1: &PoolInfo)
9ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
10Call table_queue::length<StakedSui>(&TableQueue<StakedSui>): u64
11Pack[17](ValidatorStakedInfo)
12StLoc[6](loc2: ValidatorStakedInfo)
13ImmBorrowLoc[6](loc2: ValidatorStakedInfo)
14ImmBorrowField[24](ValidatorStakedInfo.staked_sui_count: u64)
15ReadRef
16LdU64(0)
17Eq
18BrFalse(27)
B1:
19MoveLoc[1](Arg1: &mut SuiSystemState)
20Pop
21MoveLoc[5](loc1: &PoolInfo)
22Pop
23MoveLoc[3](Arg3: &TxContext)
24Pop
25MoveLoc[6](loc2: ValidatorStakedInfo)
26Ret
B2:
27CopyLoc[5](loc1: &PoolInfo)
28ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
29Call table_queue::tail<StakedSui>(&TableQueue<StakedSui>): u64
30StLoc[8](loc4: u64)
31CopyLoc[5](loc1: &PoolInfo)
32ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
33Call table_queue::head<StakedSui>(&TableQueue<StakedSui>): u64
34StLoc[4](loc0: u64)
B3:
35CopyLoc[4](loc0: u64)
36CopyLoc[8](loc4: u64)
37Lt
38BrFalse(71)
B4:
39Branch(40)
B5:
40CopyLoc[5](loc1: &PoolInfo)
41ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
42CopyLoc[4](loc0: u64)
43Call table_queue::borrow<StakedSui>(&TableQueue<StakedSui>, u64): &StakedSui
44StLoc[7](loc3: &StakedSui)
45ImmBorrowLoc[6](loc2: ValidatorStakedInfo)
46ImmBorrowField[25](ValidatorStakedInfo.total_staked: u64)
47ReadRef
48CopyLoc[7](loc3: &StakedSui)
49Call staking_pool::staked_sui_amount(&StakedSui): u64
50Add
51MutBorrowLoc[6](loc2: ValidatorStakedInfo)
52MutBorrowField[25](ValidatorStakedInfo.total_staked: u64)
53WriteRef
54ImmBorrowLoc[6](loc2: ValidatorStakedInfo)
55ImmBorrowField[26](ValidatorStakedInfo.rewards: u64)
56ReadRef
57CopyLoc[1](Arg1: &mut SuiSystemState)
58MoveLoc[7](loc3: &StakedSui)
59CopyLoc[3](Arg3: &TxContext)
60Call tx_context::epoch(&TxContext): u64
61Call calculate_staked_sui_rewards(&mut SuiSystemState, &StakedSui, u64): u64
62Add
63MutBorrowLoc[6](loc2: ValidatorStakedInfo)
64MutBorrowField[26](ValidatorStakedInfo.rewards: u64)
65WriteRef
66MoveLoc[4](loc0: u64)
67LdU64(1)
68Add
69StLoc[4](loc0: u64)
70Branch(35)
B6:
71MoveLoc[1](Arg1: &mut SuiSystemState)
72Pop
73MoveLoc[5](loc1: &PoolInfo)
74Pop
75MoveLoc[3](Arg3: &TxContext)
76Pop
77MoveLoc[6](loc2: ValidatorStakedInfo)
78Ret
}
 
public get_current_validator_staked_info_detail_vector(Arg0: &Staking, Arg1: &mut SuiSystemState, Arg2: bool, Arg3: &TxContext): vector<ValidatorStakedInfoV2> {
L4: loc0: u64
L5: loc1: u64
L6: loc2: vector<ValidatorStakedInfoV2>
L7: loc3: address
B0:
0VecPack(49, 0)
1StLoc[6](loc2: vector<ValidatorStakedInfoV2>)
2CopyLoc[0](Arg0: &Staking)
3ImmBorrowField[13](Staking.validators: vector<address>)
4VecLen(60)
5StLoc[5](loc1: u64)
6LdU64(0)
7StLoc[4](loc0: u64)
B1:
8CopyLoc[4](loc0: u64)
9CopyLoc[5](loc1: u64)
10Lt
11BrFalse(32)
B2:
12Branch(13)
B3:
13CopyLoc[0](Arg0: &Staking)
14ImmBorrowField[13](Staking.validators: vector<address>)
15CopyLoc[4](loc0: u64)
16VecImmBorrow(60)
17ReadRef
18StLoc[7](loc3: address)
19MoveLoc[4](loc0: u64)
20LdU64(1)
21Add
22StLoc[4](loc0: u64)
23MutBorrowLoc[6](loc2: vector<ValidatorStakedInfoV2>)
24CopyLoc[0](Arg0: &Staking)
25CopyLoc[1](Arg1: &mut SuiSystemState)
26MoveLoc[7](loc3: address)
27CopyLoc[2](Arg2: bool)
28CopyLoc[3](Arg3: &TxContext)
29Call get_current_validator_staked_info_detail_single(&Staking, &mut SuiSystemState, address, bool, &TxContext): ValidatorStakedInfoV2
30VecPushBack(49)
31Branch(8)
B4:
32MoveLoc[1](Arg1: &mut SuiSystemState)
33Pop
34MoveLoc[0](Arg0: &Staking)
35Pop
36MoveLoc[3](Arg3: &TxContext)
37Pop
38MoveLoc[6](loc2: vector<ValidatorStakedInfoV2>)
39Ret
}
 
public destroy_ValidatorStakedInfoV2(Arg0: ValidatorStakedInfoV2) {
B0:
0MoveLoc[0](Arg0: ValidatorStakedInfoV2)
1Unpack[18](ValidatorStakedInfoV2)
2Pop
3Pop
4Pop
5Pop
6Pop
7Pop
8Pop
9Ret
}
 
public get_current_validator_staked_info_detail_single(Arg0: &Staking, Arg1: &mut SuiSystemState, Arg2: address, Arg3: bool, Arg4: &TxContext): ValidatorStakedInfoV2 {
L5: loc0: u64
L6: loc1: VecMap<u64, u64>
L7: loc2: &Table<u64, PoolTokenExchangeRate>
L8: loc3: u64
L9: loc4: &PoolInfo
L10: loc5: ValidatorStakedInfoV2
L11: loc6: u64
L12: loc7: &StakedSui
L13: loc8: u64
B0:
0CopyLoc[0](Arg0: &Staking)
1ImmBorrowField[16](Staking.pools: Table<address, PoolInfo>)
2CopyLoc[2](Arg2: address)
3Call table::borrow<address, PoolInfo>(&Table<address, PoolInfo>, address): &PoolInfo
4StLoc[9](loc4: &PoolInfo)
5MoveLoc[2](Arg2: address)
6CopyLoc[9](loc4: &PoolInfo)
7ImmBorrowField[18](PoolInfo.total_staked: u64)
8ReadRef
9CopyLoc[9](loc4: &PoolInfo)
10ImmBorrowField[20](PoolInfo.rewards: u64)
11ReadRef
12CopyLoc[9](loc4: &PoolInfo)
13ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
14Call table_queue::length<StakedSui>(&TableQueue<StakedSui>): u64
15MoveLoc[0](Arg0: &Staking)
16Call object::id<Staking>(&Staking): ID
17LdConst[28](vector<u64>: 00)
18LdConst[28](vector<u64>: 00)
19Pack[18](ValidatorStakedInfoV2)
20StLoc[10](loc5: ValidatorStakedInfoV2)
21ImmBorrowLoc[10](loc5: ValidatorStakedInfoV2)
22ImmBorrowField[27](ValidatorStakedInfoV2.staked_sui_count: u64)
23ReadRef
24LdU64(0)
25Eq
26BrFalse(35)
B1:
27MoveLoc[1](Arg1: &mut SuiSystemState)
28Pop
29MoveLoc[9](loc4: &PoolInfo)
30Pop
31MoveLoc[4](Arg4: &TxContext)
32Pop
33MoveLoc[10](loc5: ValidatorStakedInfoV2)
34Ret
B2:
35CopyLoc[3](Arg3: bool)
36BrFalse(45)
B3:
37LdU64(0)
38MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
39MutBorrowField[28](ValidatorStakedInfoV2.total_staked: u64)
40WriteRef
41LdU64(0)
42MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
43MutBorrowField[29](ValidatorStakedInfoV2.rewards: u64)
44WriteRef
B4:
45Call vec_map::empty<u64, u64>(): VecMap<u64, u64>
46StLoc[6](loc1: VecMap<u64, u64>)
47MoveLoc[4](Arg4: &TxContext)
48Call tx_context::epoch(&TxContext): u64
49StLoc[5](loc0: u64)
50CopyLoc[9](loc4: &PoolInfo)
51ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
52Call table_queue::tail<StakedSui>(&TableQueue<StakedSui>): u64
53StLoc[13](loc8: u64)
54CopyLoc[9](loc4: &PoolInfo)
55ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
56Call table_queue::head<StakedSui>(&TableQueue<StakedSui>): u64
57StLoc[8](loc3: u64)
B5:
58CopyLoc[8](loc3: u64)
59CopyLoc[13](loc8: u64)
60Lt
61BrFalse(148)
B6:
62Branch(63)
B7:
63CopyLoc[9](loc4: &PoolInfo)
64ImmBorrowField[19](PoolInfo.staked_suis: TableQueue<StakedSui>)
65CopyLoc[8](loc3: u64)
66Call table_queue::borrow<StakedSui>(&TableQueue<StakedSui>, u64): &StakedSui
67StLoc[12](loc7: &StakedSui)
68CopyLoc[3](Arg3: bool)
69BrFalse(90)
B8:
70ImmBorrowLoc[10](loc5: ValidatorStakedInfoV2)
71ImmBorrowField[28](ValidatorStakedInfoV2.total_staked: u64)
72ReadRef
73CopyLoc[12](loc7: &StakedSui)
74Call staking_pool::staked_sui_amount(&StakedSui): u64
75Add
76MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
77MutBorrowField[28](ValidatorStakedInfoV2.total_staked: u64)
78WriteRef
79ImmBorrowLoc[10](loc5: ValidatorStakedInfoV2)
80ImmBorrowField[29](ValidatorStakedInfoV2.rewards: u64)
81ReadRef
82CopyLoc[1](Arg1: &mut SuiSystemState)
83CopyLoc[12](loc7: &StakedSui)
84CopyLoc[5](loc0: u64)
85Call calculate_staked_sui_rewards(&mut SuiSystemState, &StakedSui, u64): u64
86Add
87MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
88MutBorrowField[29](ValidatorStakedInfoV2.rewards: u64)
89WriteRef
B9:
90CopyLoc[12](loc7: &StakedSui)
91Call staking_pool::stake_activation_epoch(&StakedSui): u64
92StLoc[11](loc6: u64)
93MoveLoc[12](loc7: &StakedSui)
94Call staking_pool::pool_id(&StakedSui): ID
95MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
96MutBorrowField[30](ValidatorStakedInfoV2.pool_id: ID)
97WriteRef
98CopyLoc[1](Arg1: &mut SuiSystemState)
99ImmBorrowLoc[10](loc5: ValidatorStakedInfoV2)
100ImmBorrowField[30](ValidatorStakedInfoV2.pool_id: ID)
101Call sui_system::pool_exchange_rates(&mut SuiSystemState, &ID): &Table<u64, PoolTokenExchangeRate>
102StLoc[7](loc2: &Table<u64, PoolTokenExchangeRate>)
103CopyLoc[7](loc2: &Table<u64, PoolTokenExchangeRate>)
104CopyLoc[5](loc0: u64)
105Call table::contains<u64, PoolTokenExchangeRate>(&Table<u64, PoolTokenExchangeRate>, u64): bool
106Not
107BrFalse(121)
B10:
108ImmBorrowLoc[6](loc1: VecMap<u64, u64>)
109ImmBorrowLoc[5](loc0: u64)
110Call vec_map::contains<u64, u64>(&VecMap<u64, u64>, &u64): bool
111Not
112BrFalse(121)
B11:
113MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
114MutBorrowField[31](ValidatorStakedInfoV2.exchange_rates_unexisted_epoches: vector<u64>)
115CopyLoc[5](loc0: u64)
116VecPushBack(29)
117MutBorrowLoc[6](loc1: VecMap<u64, u64>)
118CopyLoc[5](loc0: u64)
119LdU64(0)
120Call vec_map::insert<u64, u64>(&mut VecMap<u64, u64>, u64, u64)
B12:
121MoveLoc[7](loc2: &Table<u64, PoolTokenExchangeRate>)
122CopyLoc[11](loc6: u64)
123Call table::contains<u64, PoolTokenExchangeRate>(&Table<u64, PoolTokenExchangeRate>, u64): bool
124Not
125BrFalse(139)
B13:
126ImmBorrowLoc[6](loc1: VecMap<u64, u64>)
127ImmBorrowLoc[11](loc6: u64)
128Call vec_map::contains<u64, u64>(&VecMap<u64, u64>, &u64): bool
129Not
130BrFalse(139)
B14:
131MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
132MutBorrowField[31](ValidatorStakedInfoV2.exchange_rates_unexisted_epoches: vector<u64>)
133CopyLoc[11](loc6: u64)
134VecPushBack(29)
135MutBorrowLoc[6](loc1: VecMap<u64, u64>)
136CopyLoc[11](loc6: u64)
137LdU64(0)
138Call vec_map::insert<u64, u64>(&mut VecMap<u64, u64>, u64, u64)
B15:
139MutBorrowLoc[10](loc5: ValidatorStakedInfoV2)
140MutBorrowField[32](ValidatorStakedInfoV2.stake_activation_epoches: vector<u64>)
141MoveLoc[11](loc6: u64)
142VecPushBack(29)
143MoveLoc[8](loc3: u64)
144LdU64(1)
145Add
146StLoc[8](loc3: u64)
147Branch(58)
B16:
148MoveLoc[1](Arg1: &mut SuiSystemState)
149Pop
150MoveLoc[9](loc4: &PoolInfo)
151Pop
152MoveLoc[10](loc5: ValidatorStakedInfoV2)
153Ret
}
 
public get_user_selected_staking(Arg0: &mut Staking): vector<UserSelectedStaking> {
L1: loc0: u64
L2: loc1: vector<address>
L3: loc2: u64
L4: loc3: vector<UserSelectedStaking>
L5: loc4: &address
L6: loc5: &Balance<SUI>
B0:
0VecPack(167, 0)
1StLoc[4](loc3: vector<UserSelectedStaking>)
2CopyLoc[0](Arg0: &mut Staking)
3ImmBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
4Call vec_map::keys<address, Balance<SUI>>(&VecMap<address, Balance<SUI>>): vector<address>
5StLoc[2](loc1: vector<address>)
6ImmBorrowLoc[2](loc1: vector<address>)
7VecLen(60)
8StLoc[3](loc2: u64)
9LdU64(0)
10StLoc[1](loc0: u64)
B1:
11CopyLoc[1](loc0: u64)
12CopyLoc[3](loc2: u64)
13Lt
14BrFalse(37)
B2:
15Branch(16)
B3:
16ImmBorrowLoc[2](loc1: vector<address>)
17CopyLoc[1](loc0: u64)
18VecImmBorrow(60)
19StLoc[5](loc4: &address)
20CopyLoc[0](Arg0: &mut Staking)
21ImmBorrowField[6](Staking.user_selected_validator_bals: VecMap<address, Balance<SUI>>)
22CopyLoc[5](loc4: &address)
23Call vec_map::get<address, Balance<SUI>>(&VecMap<address, Balance<SUI>>, &address): &Balance<SUI>
24StLoc[6](loc5: &Balance<SUI>)
25MutBorrowLoc[4](loc3: vector<UserSelectedStaking>)
26MoveLoc[5](loc4: &address)
27ReadRef
28MoveLoc[6](loc5: &Balance<SUI>)
29Call balance::value<SUI>(&Balance<SUI>): u64
30Pack[19](UserSelectedStaking)
31VecPushBack(167)
32MoveLoc[1](loc0: u64)
33LdU64(1)
34Add
35StLoc[1](loc0: u64)
36Branch(11)
B4:
37MoveLoc[0](Arg0: &mut Staking)
38Pop
39MoveLoc[4](loc3: vector<UserSelectedStaking>)
40Ret
}
 
public ticket_unstake_timestamp_ms(Arg0: &UnstakeTicket): u64 {
B0:
0MoveLoc[0](Arg0: &UnstakeTicket)
1ImmBorrowField[33](UnstakeTicket.unstake_timestamp_ms: u64)
2ReadRef
3Ret
}
 
public ticket_st_amount(Arg0: &UnstakeTicket): u64 {
B0:
0MoveLoc[0](Arg0: &UnstakeTicket)
1ImmBorrowField[34](UnstakeTicket.st_amount: u64)
2ReadRef
3Ret
}
 
public ticket_sui_amount(Arg0: &UnstakeTicket): u64 {
B0:
0MoveLoc[0](Arg0: &UnstakeTicket)
1ImmBorrowField[35](UnstakeTicket.sui_amount: u64)
2ReadRef
3Ret
}
 
public ticket_claim_epoch(Arg0: &UnstakeTicket): u64 {
B0:
0MoveLoc[0](Arg0: &UnstakeTicket)
1ImmBorrowField[36](UnstakeTicket.claim_epoch: u64)
2ReadRef
3Ret
}
 
public ticket_claim_timestamp_ms(Arg0: &UnstakeTicket): u64 {
B0:
0MoveLoc[0](Arg0: &UnstakeTicket)
1ImmBorrowField[37](UnstakeTicket.claim_timestamp_ms: u64)
2ReadRef
3Ret
}
 
Constants [
0 => u64: 1000000000
1 => u64: 0
2 => u64: 1000000
3 => u64: 900000
4 => u64: 10000000
5 => u64: 72000000
6 => u64: 86400000
7 => u64: 10
8 => u64: 18446744073709551615
9 => vector<u8>: "pause_claim_key" // interpreted as UTF8 string
10 => u64: 5
11 => u64: 1
12 => u64: 2
13 => u64: 3
14 => u64: 4
15 => u64: 6
16 => u64: 7
17 => u64: 8
18 => u64: 9
19 => u64: 11
20 => u64: 12
21 => u64: 13
22 => u64: 16
23 => u64: 17
24 => u64: 18
25 => u64: 19
26 => u64: 20
27 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
28 => vector<u64>: 00
]
}