staking_pool
Module0x0000…0003
- Move path
- 0x0000…0003::staking_pool
- Functions
- 4219 public, 2 entry
- Structs
- 7
- Friend modules
- sui_systemvalidatorvalidator_set
staking_pool
Bytecode1529 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module 3.staking_pool {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::sui;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct StakingPool has store, key {
id: UID,
activation_epoch: Option<u64>,
deactivation_epoch: Option<u64>,
sui_balance: u64,
rewards_pool: Balance<SUI>,
pool_token_balance: u64,
exchange_rates: Table<u64, PoolTokenExchangeRate>,
pending_stake: u64,
pending_total_sui_withdraw: u64,
pending_pool_token_withdraw: u64,
extra_fields: Bag
}
struct PoolTokenExchangeRate has copy, drop, store {
sui_amount: u64,
pool_token_amount: u64
}
struct StakedSui has store, key {
id: UID,
pool_id: ID,
stake_activation_epoch: u64,
principal: Balance<SUI>
}
struct FungibleStakedSui has store, key {
id: UID,
pool_id: ID,
value: u64
}
struct FungibleStakedSuiData has store, key {
id: UID,
total_supply: u64,
principal: Balance<SUI>
}
struct FungibleStakedSuiDataKey has copy, drop, store {
dummy_field: bool
}
struct UnderflowSuiBalance has copy, drop, store {
dummy_field: bool
}
public(friend) new(Arg0: &mut TxContext): StakingPool {
B0:
0CopyLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Call option::none<u64>(): Option<u64>
3Call option::none<u64>(): Option<u64>
4LdU64(0)
5Call balance::zero<SUI>(): Balance<SUI>
6LdU64(0)
7CopyLoc[0](Arg0: &mut TxContext)
8Call table::new<u64, PoolTokenExchangeRate>(&mut TxContext): Table<u64, PoolTokenExchangeRate>
9LdU64(0)
10LdU64(0)
11LdU64(0)
12MoveLoc[0](Arg0: &mut TxContext)
13Call bag::new(&mut TxContext): Bag
14Pack[0](StakingPool)
15Ret
}
public(friend) request_add_stake(Arg0: &mut StakingPool, Arg1: Balance<SUI>, Arg2: u64, Arg3: &mut TxContext): StakedSui {
L4: loc0: u64
B0:
0ImmBorrowLoc[1](Arg1: Balance<SUI>)
1Call balance::value<SUI>(&Balance<SUI>): u64
2StLoc[4](loc0: u64)
3CopyLoc[0](Arg0: &mut StakingPool)
4FreezeRef
5Call is_inactive(&StakingPool): bool
6Not
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &mut StakingPool)
10Pop
11MoveLoc[3](Arg3: &mut TxContext)
12Pop
13LdConst[11](u64: 10)
14Abort
B3:
15CopyLoc[4](loc0: u64)
16LdU64(0)
17Gt
18BrFalse(20)
B4:
19Branch(26)
B5:
20MoveLoc[0](Arg0: &mut StakingPool)
21Pop
22MoveLoc[3](Arg3: &mut TxContext)
23Pop
24LdConst[18](u64: 17)
25Abort
B6:
26CopyLoc[0](Arg0: &mut StakingPool)
27ImmBorrowField[0](StakingPool.pending_stake: u64)
28ReadRef
29MoveLoc[4](loc0: u64)
30Add
31CopyLoc[0](Arg0: &mut StakingPool)
32MutBorrowField[0](StakingPool.pending_stake: u64)
33WriteRef
34MoveLoc[3](Arg3: &mut TxContext)
35Call object::new(&mut TxContext): UID
36MoveLoc[0](Arg0: &mut StakingPool)
37FreezeRef
38Call object::id<StakingPool>(&StakingPool): ID
39MoveLoc[2](Arg2: u64)
40MoveLoc[1](Arg1: Balance<SUI>)
41Pack[2](StakedSui)
42Ret
}
public(friend) request_withdraw_stake(Arg0: &mut StakingPool, Arg1: StakedSui, Arg2: &TxContext): Balance<SUI> {
L3: loc0: bool
L4: loc1: bool
L5: loc2: u64
L6: loc3: Balance<SUI>
L7: loc4: Balance<SUI>
L8: loc5: u64
L9: loc6: Balance<SUI>
L10: loc7: u64
B0:
0ImmBorrowLoc[1](Arg1: StakedSui)
1ImmBorrowField[1](StakedSui.stake_activation_epoch: u64)
2ReadRef
3CopyLoc[2](Arg2: &TxContext)
4Call tx_context::epoch(&TxContext): u64
5Gt
6BrFalse(13)
B1:
7CopyLoc[0](Arg0: &mut StakingPool)
8FreezeRef
9Call is_preactive(&StakingPool): bool
10Not
11StLoc[3](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[3](loc0: bool)
B3:
15MoveLoc[3](loc0: bool)
16BrFalse(33)
B4:
17MoveLoc[2](Arg2: &TxContext)
18Pop
19MoveLoc[1](Arg1: StakedSui)
20Call unwrap_staked_sui(StakedSui): Balance<SUI>
21StLoc[6](loc3: Balance<SUI>)
22CopyLoc[0](Arg0: &mut StakingPool)
23ImmBorrowField[0](StakingPool.pending_stake: u64)
24ReadRef
25ImmBorrowLoc[6](loc3: Balance<SUI>)
26Call balance::value<SUI>(&Balance<SUI>): u64
27Sub
28MoveLoc[0](Arg0: &mut StakingPool)
29MutBorrowField[0](StakingPool.pending_stake: u64)
30WriteRef
31MoveLoc[6](loc3: Balance<SUI>)
32Ret
B5:
33CopyLoc[0](Arg0: &mut StakingPool)
34FreezeRef
35MoveLoc[1](Arg1: StakedSui)
36Call withdraw_from_principal(&StakingPool, StakedSui): u64 * Balance<SUI>
37StLoc[7](loc4: Balance<SUI>)
38StLoc[5](loc2: u64)
39ImmBorrowLoc[7](loc4: Balance<SUI>)
40Call balance::value<SUI>(&Balance<SUI>): u64
41StLoc[8](loc5: u64)
42CopyLoc[0](Arg0: &mut StakingPool)
43CopyLoc[8](loc5: u64)
44CopyLoc[5](loc2: u64)
45MoveLoc[2](Arg2: &TxContext)
46Call tx_context::epoch(&TxContext): u64
47Call withdraw_rewards(&mut StakingPool, u64, u64, u64): Balance<SUI>
48StLoc[9](loc6: Balance<SUI>)
49MoveLoc[8](loc5: u64)
50ImmBorrowLoc[9](loc6: Balance<SUI>)
51Call balance::value<SUI>(&Balance<SUI>): u64
52Add
53StLoc[10](loc7: u64)
54CopyLoc[0](Arg0: &mut StakingPool)
55ImmBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
56ReadRef
57MoveLoc[10](loc7: u64)
58Add
59CopyLoc[0](Arg0: &mut StakingPool)
60MutBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
61WriteRef
62CopyLoc[0](Arg0: &mut StakingPool)
63ImmBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
64ReadRef
65MoveLoc[5](loc2: u64)
66Add
67CopyLoc[0](Arg0: &mut StakingPool)
68MutBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
69WriteRef
70CopyLoc[0](Arg0: &mut StakingPool)
71FreezeRef
72Call is_inactive(&StakingPool): bool
73BrFalse(77)
B6:
74LdTrue
75StLoc[4](loc1: bool)
76Branch(81)
B7:
77CopyLoc[0](Arg0: &mut StakingPool)
78FreezeRef
79Call is_preactive(&StakingPool): bool
80StLoc[4](loc1: bool)
B8:
81MoveLoc[4](loc1: bool)
82BrFalse(86)
B9:
83MoveLoc[0](Arg0: &mut StakingPool)
84Call process_pending_stake_withdraw(&mut StakingPool)
85Branch(88)
B10:
86MoveLoc[0](Arg0: &mut StakingPool)
87Pop
B11:
88MutBorrowLoc[7](loc4: Balance<SUI>)
89MoveLoc[9](loc6: Balance<SUI>)
90Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
91Pop
92MoveLoc[7](loc4: Balance<SUI>)
93Ret
}
public(friend) redeem_fungible_staked_sui(Arg0: &mut StakingPool, Arg1: FungibleStakedSui, Arg2: &TxContext): Balance<SUI> {
L3: loc0: &mut FungibleStakedSuiData
L4: loc1: UID
L5: loc2: PoolTokenExchangeRate
L6: loc3: ID
L7: loc4: u64
L8: loc5: u64
L9: loc6: Balance<SUI>
L10: loc7: u64
B0:
0MoveLoc[1](Arg1: FungibleStakedSui)
1Unpack[3](FungibleStakedSui)
2StLoc[10](loc7: u64)
3StLoc[6](loc3: ID)
4StLoc[4](loc1: UID)
5MoveLoc[6](loc3: ID)
6CopyLoc[0](Arg0: &mut StakingPool)
7FreezeRef
8Call object::id<StakingPool>(&StakingPool): ID
9Eq
10BrFalse(12)
B1:
11Branch(18)
B2:
12MoveLoc[0](Arg0: &mut StakingPool)
13Pop
14MoveLoc[2](Arg2: &TxContext)
15Pop
16LdConst[2](u64: 1)
17Abort
B3:
18MoveLoc[4](loc1: UID)
19Call object::delete(UID)
20CopyLoc[0](Arg0: &mut StakingPool)
21FreezeRef
22MoveLoc[2](Arg2: &TxContext)
23Call tx_context::epoch(&TxContext): u64
24Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
25StLoc[5](loc2: PoolTokenExchangeRate)
26CopyLoc[0](Arg0: &mut StakingPool)
27MutBorrowField[4](StakingPool.extra_fields: Bag)
28LdFalse
29Pack[5](FungibleStakedSuiDataKey)
30Call bag::borrow_mut<FungibleStakedSuiDataKey, FungibleStakedSuiData>(&mut Bag, FungibleStakedSuiDataKey): &mut FungibleStakedSuiData
31StLoc[3](loc0: &mut FungibleStakedSuiData)
32MoveLoc[5](loc2: PoolTokenExchangeRate)
33CopyLoc[10](loc7: u64)
34CopyLoc[3](loc0: &mut FungibleStakedSuiData)
35ImmBorrowField[5](FungibleStakedSuiData.principal: Balance<SUI>)
36Call balance::value<SUI>(&Balance<SUI>): u64
37CopyLoc[3](loc0: &mut FungibleStakedSuiData)
38ImmBorrowField[6](FungibleStakedSuiData.total_supply: u64)
39ReadRef
40Call calculate_fungible_staked_sui_withdraw_amount(PoolTokenExchangeRate, u64, u64, u64): u64 * u64
41StLoc[8](loc5: u64)
42StLoc[7](loc4: u64)
43CopyLoc[3](loc0: &mut FungibleStakedSuiData)
44ImmBorrowField[6](FungibleStakedSuiData.total_supply: u64)
45ReadRef
46CopyLoc[10](loc7: u64)
47Sub
48CopyLoc[3](loc0: &mut FungibleStakedSuiData)
49MutBorrowField[6](FungibleStakedSuiData.total_supply: u64)
50WriteRef
51MoveLoc[3](loc0: &mut FungibleStakedSuiData)
52MutBorrowField[5](FungibleStakedSuiData.principal: Balance<SUI>)
53MoveLoc[7](loc4: u64)
54Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
55StLoc[9](loc6: Balance<SUI>)
56MutBorrowLoc[9](loc6: Balance<SUI>)
57CopyLoc[0](Arg0: &mut StakingPool)
58MutBorrowField[7](StakingPool.rewards_pool: Balance<SUI>)
59MoveLoc[8](loc5: u64)
60Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
61Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
62Pop
63CopyLoc[0](Arg0: &mut StakingPool)
64ImmBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
65ReadRef
66ImmBorrowLoc[9](loc6: Balance<SUI>)
67Call balance::value<SUI>(&Balance<SUI>): u64
68Add
69CopyLoc[0](Arg0: &mut StakingPool)
70MutBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
71WriteRef
72CopyLoc[0](Arg0: &mut StakingPool)
73ImmBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
74ReadRef
75MoveLoc[10](loc7: u64)
76Add
77MoveLoc[0](Arg0: &mut StakingPool)
78MutBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
79WriteRef
80MoveLoc[9](loc6: Balance<SUI>)
81Ret
}
calculate_fungible_staked_sui_withdraw_amount(Arg0: PoolTokenExchangeRate, Arg1: u64, Arg2: u64, Arg3: u64): u64 * u64 {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
L8: loc4: u64
L9: loc5: u64
B0:
0ImmBorrowLoc[0](Arg0: PoolTokenExchangeRate)
1CopyLoc[3](Arg3: u64)
2Call get_sui_amount(&PoolTokenExchangeRate, u64): u64
3StLoc[9](loc5: u64)
4MoveLoc[2](Arg2: u64)
5CopyLoc[9](loc5: u64)
6Call u64::min(u64, u64): u64
7StLoc[5](loc1: u64)
8MoveLoc[9](loc5: u64)
9CopyLoc[5](loc1: u64)
10Sub
11StLoc[8](loc4: u64)
12CopyLoc[1](Arg1: u64)
13CastU128
14MoveLoc[5](loc1: u64)
15CastU128
16Mul
17CopyLoc[3](Arg3: u64)
18CastU128
19Div
20CastU64
21StLoc[6](loc2: u64)
22CopyLoc[1](Arg1: u64)
23CastU128
24MoveLoc[8](loc4: u64)
25CastU128
26Mul
27MoveLoc[3](Arg3: u64)
28CastU128
29Div
30CastU64
31StLoc[7](loc3: u64)
32ImmBorrowLoc[0](Arg0: PoolTokenExchangeRate)
33MoveLoc[1](Arg1: u64)
34Call get_sui_amount(&PoolTokenExchangeRate, u64): u64
35StLoc[4](loc0: u64)
36CopyLoc[6](loc2: u64)
37CopyLoc[7](loc3: u64)
38Add
39MoveLoc[4](loc0: u64)
40Le
41BrFalse(43)
B1:
42Branch(45)
B2:
43LdConst[21](u64: 20)
44Abort
B3:
45MoveLoc[6](loc2: u64)
46MoveLoc[7](loc3: u64)
47Ret
}
public(friend) convert_to_fungible_staked_sui(Arg0: &mut StakingPool, Arg1: StakedSui, Arg2: &mut TxContext): FungibleStakedSui {
L3: loc0: bool
L4: loc1: PoolTokenExchangeRate
L5: loc2: &mut FungibleStakedSuiData
L6: loc3: UID
L7: loc4: FungibleStakedSuiDataKey
L8: loc5: ID
L9: loc6: u64
L10: loc7: Balance<SUI>
L11: loc8: u64
B0:
0MoveLoc[1](Arg1: StakedSui)
1Unpack[2](StakedSui)
2StLoc[10](loc7: Balance<SUI>)
3StLoc[11](loc8: u64)
4StLoc[8](loc5: ID)
5StLoc[6](loc3: UID)
6CopyLoc[8](loc5: ID)
7CopyLoc[0](Arg0: &mut StakingPool)
8FreezeRef
9Call object::id<StakingPool>(&StakingPool): ID
10Eq
11BrFalse(13)
B1:
12Branch(19)
B2:
13MoveLoc[0](Arg0: &mut StakingPool)
14Pop
15MoveLoc[2](Arg2: &mut TxContext)
16Pop
17LdConst[2](u64: 1)
18Abort
B3:
19CopyLoc[2](Arg2: &mut TxContext)
20FreezeRef
21Call tx_context::epoch(&TxContext): u64
22CopyLoc[11](loc8: u64)
23Ge
24BrFalse(26)
B4:
25Branch(32)
B5:
26MoveLoc[0](Arg0: &mut StakingPool)
27Pop
28MoveLoc[2](Arg2: &mut TxContext)
29Pop
30LdConst[20](u64: 19)
31Abort
B6:
32CopyLoc[0](Arg0: &mut StakingPool)
33FreezeRef
34Call is_preactive(&StakingPool): bool
35Not
36BrFalse(43)
B7:
37CopyLoc[0](Arg0: &mut StakingPool)
38FreezeRef
39Call is_inactive(&StakingPool): bool
40Not
41StLoc[3](loc0: bool)
42Branch(45)
B8:
43LdFalse
44StLoc[3](loc0: bool)
B9:
45MoveLoc[3](loc0: bool)
46BrFalse(48)
B10:
47Branch(54)
B11:
48MoveLoc[0](Arg0: &mut StakingPool)
49Pop
50MoveLoc[2](Arg2: &mut TxContext)
51Pop
52LdConst[16](u64: 15)
53Abort
B12:
54MoveLoc[6](loc3: UID)
55Call object::delete(UID)
56CopyLoc[0](Arg0: &mut StakingPool)
57FreezeRef
58MoveLoc[11](loc8: u64)
59Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
60StLoc[4](loc1: PoolTokenExchangeRate)
61ImmBorrowLoc[4](loc1: PoolTokenExchangeRate)
62ImmBorrowLoc[10](loc7: Balance<SUI>)
63Call balance::value<SUI>(&Balance<SUI>): u64
64Call get_token_amount(&PoolTokenExchangeRate, u64): u64
65StLoc[9](loc6: u64)
66CopyLoc[9](loc6: u64)
67LdU64(0)
68Gt
69BrFalse(71)
B13:
70Branch(77)
B14:
71MoveLoc[0](Arg0: &mut StakingPool)
72Pop
73MoveLoc[2](Arg2: &mut TxContext)
74Pop
75LdConst[19](u64: 18)
76Abort
B15:
77LdFalse
78Pack[5](FungibleStakedSuiDataKey)
79StLoc[7](loc4: FungibleStakedSuiDataKey)
80CopyLoc[0](Arg0: &mut StakingPool)
81ImmBorrowField[4](StakingPool.extra_fields: Bag)
82CopyLoc[7](loc4: FungibleStakedSuiDataKey)
83Call bag::contains<FungibleStakedSuiDataKey>(&Bag, FungibleStakedSuiDataKey): bool
84Not
85BrFalse(96)
B16:
86MoveLoc[0](Arg0: &mut StakingPool)
87MutBorrowField[4](StakingPool.extra_fields: Bag)
88MoveLoc[7](loc4: FungibleStakedSuiDataKey)
89CopyLoc[2](Arg2: &mut TxContext)
90Call object::new(&mut TxContext): UID
91CopyLoc[9](loc6: u64)
92MoveLoc[10](loc7: Balance<SUI>)
93Pack[4](FungibleStakedSuiData)
94Call bag::add<FungibleStakedSuiDataKey, FungibleStakedSuiData>(&mut Bag, FungibleStakedSuiDataKey, FungibleStakedSuiData)
95Branch(114)
B17:
96MoveLoc[0](Arg0: &mut StakingPool)
97MutBorrowField[4](StakingPool.extra_fields: Bag)
98MoveLoc[7](loc4: FungibleStakedSuiDataKey)
99Call bag::borrow_mut<FungibleStakedSuiDataKey, FungibleStakedSuiData>(&mut Bag, FungibleStakedSuiDataKey): &mut FungibleStakedSuiData
100StLoc[5](loc2: &mut FungibleStakedSuiData)
101CopyLoc[5](loc2: &mut FungibleStakedSuiData)
102ImmBorrowField[6](FungibleStakedSuiData.total_supply: u64)
103ReadRef
104CopyLoc[9](loc6: u64)
105Add
106CopyLoc[5](loc2: &mut FungibleStakedSuiData)
107MutBorrowField[6](FungibleStakedSuiData.total_supply: u64)
108WriteRef
109MoveLoc[5](loc2: &mut FungibleStakedSuiData)
110MutBorrowField[5](FungibleStakedSuiData.principal: Balance<SUI>)
111MoveLoc[10](loc7: Balance<SUI>)
112Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
113Pop
B18:
114MoveLoc[2](Arg2: &mut TxContext)
115Call object::new(&mut TxContext): UID
116MoveLoc[8](loc5: ID)
117MoveLoc[9](loc6: u64)
118Pack[3](FungibleStakedSui)
119Ret
}
public(friend) withdraw_from_principal(Arg0: &StakingPool, Arg1: StakedSui): u64 * Balance<SUI> {
L2: loc0: PoolTokenExchangeRate
L3: loc1: Balance<SUI>
B0:
0ImmBorrowLoc[1](Arg1: StakedSui)
1ImmBorrowField[8](StakedSui.pool_id: ID)
2ReadRef
3CopyLoc[0](Arg0: &StakingPool)
4Call object::id<StakingPool>(&StakingPool): ID
5Eq
6BrFalse(8)
B1:
7Branch(12)
B2:
8MoveLoc[0](Arg0: &StakingPool)
9Pop
10LdConst[2](u64: 1)
11Abort
B3:
12MoveLoc[0](Arg0: &StakingPool)
13ImmBorrowLoc[1](Arg1: StakedSui)
14ImmBorrowField[1](StakedSui.stake_activation_epoch: u64)
15ReadRef
16Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
17StLoc[2](loc0: PoolTokenExchangeRate)
18MoveLoc[1](Arg1: StakedSui)
19Call unwrap_staked_sui(StakedSui): Balance<SUI>
20StLoc[3](loc1: Balance<SUI>)
21ImmBorrowLoc[2](loc0: PoolTokenExchangeRate)
22ImmBorrowLoc[3](loc1: Balance<SUI>)
23Call balance::value<SUI>(&Balance<SUI>): u64
24Call get_token_amount(&PoolTokenExchangeRate, u64): u64
25MoveLoc[3](loc1: Balance<SUI>)
26Ret
}
unwrap_staked_sui(Arg0: StakedSui): Balance<SUI> {
L1: loc0: Balance<SUI>
B0:
0MoveLoc[0](Arg0: StakedSui)
1Unpack[2](StakedSui)
2StLoc[1](loc0: Balance<SUI>)
3Pop
4Pop
5Call object::delete(UID)
6MoveLoc[1](loc0: Balance<SUI>)
7Ret
}
public(friend) deposit_rewards(Arg0: &mut StakingPool, Arg1: Balance<SUI>) {
B0:
0CopyLoc[0](Arg0: &mut StakingPool)
1ImmBorrowField[9](StakingPool.sui_balance: u64)
2ReadRef
3ImmBorrowLoc[1](Arg1: Balance<SUI>)
4Call balance::value<SUI>(&Balance<SUI>): u64
5Add
6CopyLoc[0](Arg0: &mut StakingPool)
7MutBorrowField[9](StakingPool.sui_balance: u64)
8WriteRef
9MoveLoc[0](Arg0: &mut StakingPool)
10MutBorrowField[7](StakingPool.rewards_pool: Balance<SUI>)
11MoveLoc[1](Arg1: Balance<SUI>)
12Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
13Pop
14Ret
}
public(friend) process_pending_stakes_and_withdraws(Arg0: &mut StakingPool, Arg1: &TxContext) {
L2: loc0: u64
B0:
0MoveLoc[1](Arg1: &TxContext)
1Call tx_context::epoch(&TxContext): u64
2LdU64(1)
3Add
4StLoc[2](loc0: u64)
5CopyLoc[0](Arg0: &mut StakingPool)
6Call process_pending_stake_withdraw(&mut StakingPool)
7CopyLoc[0](Arg0: &mut StakingPool)
8Call process_pending_stake(&mut StakingPool)
9CopyLoc[0](Arg0: &mut StakingPool)
10MutBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
11CopyLoc[2](loc0: u64)
12CopyLoc[0](Arg0: &mut StakingPool)
13ImmBorrowField[9](StakingPool.sui_balance: u64)
14ReadRef
15CopyLoc[0](Arg0: &mut StakingPool)
16ImmBorrowField[11](StakingPool.pool_token_balance: u64)
17ReadRef
18Pack[1](PoolTokenExchangeRate)
19Call table::add<u64, PoolTokenExchangeRate>(&mut Table<u64, PoolTokenExchangeRate>, u64, PoolTokenExchangeRate)
20MoveLoc[0](Arg0: &mut StakingPool)
21FreezeRef
22MoveLoc[2](loc0: u64)
23Call check_balance_invariants(&StakingPool, u64)
24Ret
}
process_pending_stake_withdraw(Arg0: &mut StakingPool) {
L1: loc0: u64
L2: loc1: u64
L3: loc2: u64
B0:
0CopyLoc[0](Arg0: &mut StakingPool)
1ImmBorrowField[9](StakingPool.sui_balance: u64)
2ReadRef
3CopyLoc[0](Arg0: &mut StakingPool)
4ImmBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
5ReadRef
6Ge
7BrFalse(17)
B1:
8CopyLoc[0](Arg0: &mut StakingPool)
9ImmBorrowField[9](StakingPool.sui_balance: u64)
10ReadRef
11CopyLoc[0](Arg0: &mut StakingPool)
12ImmBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
13ReadRef
14Sub
15StLoc[1](loc0: u64)
16Branch(38)
B2:
17CopyLoc[0](Arg0: &mut StakingPool)
18ImmBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
19ReadRef
20CopyLoc[0](Arg0: &mut StakingPool)
21ImmBorrowField[9](StakingPool.sui_balance: u64)
22ReadRef
23Sub
24StLoc[3](loc2: u64)
25CopyLoc[0](Arg0: &mut StakingPool)
26FreezeRef
27Call is_inactive(&StakingPool): bool
28Not
29BrFalse(36)
B3:
30CopyLoc[0](Arg0: &mut StakingPool)
31MutBorrowField[4](StakingPool.extra_fields: Bag)
32LdFalse
33Pack[6](UnderflowSuiBalance)
34MoveLoc[3](loc2: u64)
35Call bag::add<UnderflowSuiBalance, u64>(&mut Bag, UnderflowSuiBalance, u64)
B4:
36LdU64(0)
37StLoc[1](loc0: u64)
B5:
38MoveLoc[1](loc0: u64)
39CopyLoc[0](Arg0: &mut StakingPool)
40MutBorrowField[9](StakingPool.sui_balance: u64)
41WriteRef
42CopyLoc[0](Arg0: &mut StakingPool)
43ImmBorrowField[11](StakingPool.pool_token_balance: u64)
44ReadRef
45CopyLoc[0](Arg0: &mut StakingPool)
46ImmBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
47ReadRef
48Ge
49BrFalse(59)
B6:
50CopyLoc[0](Arg0: &mut StakingPool)
51ImmBorrowField[11](StakingPool.pool_token_balance: u64)
52ReadRef
53CopyLoc[0](Arg0: &mut StakingPool)
54ImmBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
55ReadRef
56Sub
57StLoc[2](loc1: u64)
58Branch(61)
B7:
59LdU64(0)
60StLoc[2](loc1: u64)
B8:
61MoveLoc[2](loc1: u64)
62CopyLoc[0](Arg0: &mut StakingPool)
63MutBorrowField[11](StakingPool.pool_token_balance: u64)
64WriteRef
65LdU64(0)
66CopyLoc[0](Arg0: &mut StakingPool)
67MutBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
68WriteRef
69LdU64(0)
70MoveLoc[0](Arg0: &mut StakingPool)
71MutBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
72WriteRef
73Ret
}
public(friend) process_pending_stake(Arg0: &mut StakingPool) {
L1: loc0: u64
L2: loc1: UnderflowSuiBalance
L3: loc2: PoolTokenExchangeRate
L4: loc3: u64
B0:
0CopyLoc[0](Arg0: &mut StakingPool)
1ImmBorrowField[9](StakingPool.sui_balance: u64)
2ReadRef
3CopyLoc[0](Arg0: &mut StakingPool)
4ImmBorrowField[11](StakingPool.pool_token_balance: u64)
5ReadRef
6Pack[1](PoolTokenExchangeRate)
7StLoc[3](loc2: PoolTokenExchangeRate)
8LdFalse
9Pack[6](UnderflowSuiBalance)
10StLoc[2](loc1: UnderflowSuiBalance)
11CopyLoc[0](Arg0: &mut StakingPool)
12ImmBorrowField[4](StakingPool.extra_fields: Bag)
13CopyLoc[2](loc1: UnderflowSuiBalance)
14Call bag::contains<UnderflowSuiBalance>(&Bag, UnderflowSuiBalance): bool
15BrFalse(22)
B1:
16CopyLoc[0](Arg0: &mut StakingPool)
17MutBorrowField[4](StakingPool.extra_fields: Bag)
18MoveLoc[2](loc1: UnderflowSuiBalance)
19Call bag::remove<UnderflowSuiBalance, u64>(&mut Bag, UnderflowSuiBalance): u64
20StLoc[1](loc0: u64)
21Branch(24)
B2:
22LdU64(0)
23StLoc[1](loc0: u64)
B3:
24MoveLoc[1](loc0: u64)
25StLoc[4](loc3: u64)
26CopyLoc[0](Arg0: &mut StakingPool)
27ImmBorrowField[9](StakingPool.sui_balance: u64)
28ReadRef
29CopyLoc[0](Arg0: &mut StakingPool)
30ImmBorrowField[0](StakingPool.pending_stake: u64)
31ReadRef
32Add
33MoveLoc[4](loc3: u64)
34Sub
35CopyLoc[0](Arg0: &mut StakingPool)
36MutBorrowField[9](StakingPool.sui_balance: u64)
37WriteRef
38ImmBorrowLoc[3](loc2: PoolTokenExchangeRate)
39CopyLoc[0](Arg0: &mut StakingPool)
40ImmBorrowField[9](StakingPool.sui_balance: u64)
41ReadRef
42Call get_token_amount(&PoolTokenExchangeRate, u64): u64
43CopyLoc[0](Arg0: &mut StakingPool)
44MutBorrowField[11](StakingPool.pool_token_balance: u64)
45WriteRef
46LdU64(0)
47MoveLoc[0](Arg0: &mut StakingPool)
48MutBorrowField[0](StakingPool.pending_stake: u64)
49WriteRef
50Ret
}
withdraw_rewards(Arg0: &mut StakingPool, Arg1: u64, Arg2: u64, Arg3: u64): Balance<SUI> {
L4: loc0: u64
L5: loc1: PoolTokenExchangeRate
L6: loc2: u64
L7: loc3: u64
B0:
0CopyLoc[0](Arg0: &mut StakingPool)
1FreezeRef
2MoveLoc[3](Arg3: u64)
3Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
4StLoc[5](loc1: PoolTokenExchangeRate)
5ImmBorrowLoc[5](loc1: PoolTokenExchangeRate)
6MoveLoc[2](Arg2: u64)
7Call get_sui_amount(&PoolTokenExchangeRate, u64): u64
8StLoc[7](loc3: u64)
9CopyLoc[7](loc3: u64)
10CopyLoc[1](Arg1: u64)
11Ge
12BrFalse(18)
B1:
13MoveLoc[7](loc3: u64)
14MoveLoc[1](Arg1: u64)
15Sub
16StLoc[4](loc0: u64)
17Branch(20)
B2:
18LdU64(0)
19StLoc[4](loc0: u64)
B3:
20MoveLoc[4](loc0: u64)
21CopyLoc[0](Arg0: &mut StakingPool)
22ImmBorrowField[7](StakingPool.rewards_pool: Balance<SUI>)
23Call balance::value<SUI>(&Balance<SUI>): u64
24Call u64::min(u64, u64): u64
25StLoc[6](loc2: u64)
26MoveLoc[0](Arg0: &mut StakingPool)
27MutBorrowField[7](StakingPool.rewards_pool: Balance<SUI>)
28MoveLoc[6](loc2: u64)
29Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
30Ret
}
public(friend) activate_staking_pool(Arg0: &mut StakingPool, Arg1: u64) {
B0:
0CopyLoc[0](Arg0: &mut StakingPool)
1MutBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
2CopyLoc[1](Arg1: u64)
3Call initial_exchange_rate(): PoolTokenExchangeRate
4Call table::add<u64, PoolTokenExchangeRate>(&mut Table<u64, PoolTokenExchangeRate>, u64, PoolTokenExchangeRate)
5CopyLoc[0](Arg0: &mut StakingPool)
6FreezeRef
7Call is_preactive(&StakingPool): bool
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[0](Arg0: &mut StakingPool)
11Pop
12LdConst[15](u64: 14)
13Abort
B3:
14CopyLoc[0](Arg0: &mut StakingPool)
15FreezeRef
16Call is_inactive(&StakingPool): bool
17Not
18BrFalse(20)
B4:
19Branch(24)
B5:
20MoveLoc[0](Arg0: &mut StakingPool)
21Pop
22LdConst[17](u64: 16)
23Abort
B6:
24MoveLoc[0](Arg0: &mut StakingPool)
25MutBorrowField[12](StakingPool.activation_epoch: Option<u64>)
26MoveLoc[1](Arg1: u64)
27Call option::fill<u64>(&mut Option<u64>, u64)
28Ret
}
public(friend) deactivate_staking_pool(Arg0: &mut StakingPool, Arg1: u64) {
B0:
0CopyLoc[0](Arg0: &mut StakingPool)
1FreezeRef
2Call is_inactive(&StakingPool): bool
3Not
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &mut StakingPool)
7Pop
8LdConst[12](u64: 11)
9Abort
B3:
10MoveLoc[1](Arg1: u64)
11Call option::some<u64>(u64): Option<u64>
12MoveLoc[0](Arg0: &mut StakingPool)
13MutBorrowField[13](StakingPool.deactivation_epoch: Option<u64>)
14WriteRef
15Ret
}
public sui_balance(Arg0: &StakingPool): u64 {
B0:
0MoveLoc[0](Arg0: &StakingPool)
1ImmBorrowField[9](StakingPool.sui_balance: u64)
2ReadRef
3Ret
}
public pool_id(Arg0: &StakedSui): ID {
B0:
0MoveLoc[0](Arg0: &StakedSui)
1ImmBorrowField[8](StakedSui.pool_id: ID)
2ReadRef
3Ret
}
public fungible_staked_sui_pool_id(Arg0: &FungibleStakedSui): ID {
B0:
0MoveLoc[0](Arg0: &FungibleStakedSui)
1ImmBorrowField[14](FungibleStakedSui.pool_id: ID)
2ReadRef
3Ret
}
public staked_sui_amount(Arg0: &StakedSui): u64 {
B0:
0MoveLoc[0](Arg0: &StakedSui)
1ImmBorrowField[15](StakedSui.principal: Balance<SUI>)
2Call balance::value<SUI>(&Balance<SUI>): u64
3Ret
}
public stake_activation_epoch(Arg0: &StakedSui): u64 {
B0:
0MoveLoc[0](Arg0: &StakedSui)
1ImmBorrowField[1](StakedSui.stake_activation_epoch: u64)
2ReadRef
3Ret
}
public is_preactive(Arg0: &StakingPool): bool {
B0:
0MoveLoc[0](Arg0: &StakingPool)
1ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
2Call option::is_none<u64>(&Option<u64>): bool
3Ret
}
public(friend) activation_epoch(Arg0: &StakingPool): Option<u64> {
B0:
0MoveLoc[0](Arg0: &StakingPool)
1ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
2ReadRef
3Ret
}
public is_inactive(Arg0: &StakingPool): bool {
B0:
0MoveLoc[0](Arg0: &StakingPool)
1ImmBorrowField[13](StakingPool.deactivation_epoch: Option<u64>)
2Call option::is_some<u64>(&Option<u64>): bool
3Ret
}
public fungible_staked_sui_value(Arg0: &FungibleStakedSui): u64 {
B0:
0MoveLoc[0](Arg0: &FungibleStakedSui)
1ImmBorrowField[16](FungibleStakedSui.value: u64)
2ReadRef
3Ret
}
public split_fungible_staked_sui(Arg0: &mut FungibleStakedSui, Arg1: u64, Arg2: &mut TxContext): FungibleStakedSui {
B0:
0CopyLoc[1](Arg1: u64)
1CopyLoc[0](Arg0: &mut FungibleStakedSui)
2ImmBorrowField[16](FungibleStakedSui.value: u64)
3ReadRef
4Le
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[0](Arg0: &mut FungibleStakedSui)
8Pop
9MoveLoc[2](Arg2: &mut TxContext)
10Pop
11LdConst[1](u64: 0)
12Abort
B3:
13CopyLoc[0](Arg0: &mut FungibleStakedSui)
14ImmBorrowField[16](FungibleStakedSui.value: u64)
15ReadRef
16CopyLoc[1](Arg1: u64)
17Sub
18CopyLoc[0](Arg0: &mut FungibleStakedSui)
19MutBorrowField[16](FungibleStakedSui.value: u64)
20WriteRef
21MoveLoc[2](Arg2: &mut TxContext)
22Call object::new(&mut TxContext): UID
23MoveLoc[0](Arg0: &mut FungibleStakedSui)
24ImmBorrowField[14](FungibleStakedSui.pool_id: ID)
25ReadRef
26MoveLoc[1](Arg1: u64)
27Pack[3](FungibleStakedSui)
28Ret
}
public join_fungible_staked_sui(Arg0: &mut FungibleStakedSui, Arg1: FungibleStakedSui) {
L2: loc0: UID
L3: loc1: ID
L4: loc2: u64
B0:
0MoveLoc[1](Arg1: FungibleStakedSui)
1Unpack[3](FungibleStakedSui)
2StLoc[4](loc2: u64)
3StLoc[3](loc1: ID)
4StLoc[2](loc0: UID)
5CopyLoc[0](Arg0: &mut FungibleStakedSui)
6ImmBorrowField[14](FungibleStakedSui.pool_id: ID)
7ReadRef
8MoveLoc[3](loc1: ID)
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut FungibleStakedSui)
13Pop
14LdConst[2](u64: 1)
15Abort
B3:
16MoveLoc[2](loc0: UID)
17Call object::delete(UID)
18CopyLoc[0](Arg0: &mut FungibleStakedSui)
19ImmBorrowField[16](FungibleStakedSui.value: u64)
20ReadRef
21MoveLoc[4](loc2: u64)
22Add
23MoveLoc[0](Arg0: &mut FungibleStakedSui)
24MutBorrowField[16](FungibleStakedSui.value: u64)
25WriteRef
26Ret
}
public split(Arg0: &mut StakedSui, Arg1: u64, Arg2: &mut TxContext): StakedSui {
L3: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut StakedSui)
1ImmBorrowField[15](StakedSui.principal: Balance<SUI>)
2Call balance::value<SUI>(&Balance<SUI>): u64
3StLoc[3](loc0: u64)
4CopyLoc[1](Arg1: u64)
5CopyLoc[3](loc0: u64)
6Le
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &mut StakedSui)
10Pop
11MoveLoc[2](Arg2: &mut TxContext)
12Pop
13LdConst[4](u64: 3)
14Abort
B3:
15MoveLoc[3](loc0: u64)
16CopyLoc[1](Arg1: u64)
17Sub
18LdConst[0](u64: 1000..)
19Ge
20BrFalse(22)
B4:
21Branch(28)
B5:
22MoveLoc[0](Arg0: &mut StakedSui)
23Pop
24MoveLoc[2](Arg2: &mut TxContext)
25Pop
26LdConst[19](u64: 18)
27Abort
B6:
28CopyLoc[1](Arg1: u64)
29LdConst[0](u64: 1000..)
30Ge
31BrFalse(33)
B7:
32Branch(39)
B8:
33MoveLoc[0](Arg0: &mut StakedSui)
34Pop
35MoveLoc[2](Arg2: &mut TxContext)
36Pop
37LdConst[19](u64: 18)
38Abort
B9:
39MoveLoc[2](Arg2: &mut TxContext)
40Call object::new(&mut TxContext): UID
41CopyLoc[0](Arg0: &mut StakedSui)
42ImmBorrowField[8](StakedSui.pool_id: ID)
43ReadRef
44CopyLoc[0](Arg0: &mut StakedSui)
45ImmBorrowField[1](StakedSui.stake_activation_epoch: u64)
46ReadRef
47MoveLoc[0](Arg0: &mut StakedSui)
48MutBorrowField[15](StakedSui.principal: Balance<SUI>)
49MoveLoc[1](Arg1: u64)
50Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
51Pack[2](StakedSui)
52Ret
}
entry public split_staked_sui(Arg0: &mut StakedSui, Arg1: u64, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut StakedSui)
1MoveLoc[1](Arg1: u64)
2CopyLoc[2](Arg2: &mut TxContext)
3Call split(&mut StakedSui, u64, &mut TxContext): StakedSui
4MoveLoc[2](Arg2: &mut TxContext)
5FreezeRef
6Call tx_context::sender(&TxContext): address
7Call transfer::transfer<StakedSui>(StakedSui, address)
8Ret
}
entry public join_staked_sui(Arg0: &mut StakedSui, Arg1: StakedSui) {
L2: loc0: Balance<SUI>
B0:
0CopyLoc[0](Arg0: &mut StakedSui)
1FreezeRef
2ImmBorrowLoc[1](Arg1: StakedSui)
3Call is_equal_staking_metadata(&StakedSui, &StakedSui): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &mut StakedSui)
7Pop
8LdConst[13](u64: 12)
9Abort
B3:
10MoveLoc[1](Arg1: StakedSui)
11Unpack[2](StakedSui)
12StLoc[2](loc0: Balance<SUI>)
13Pop
14Pop
15Call object::delete(UID)
16MoveLoc[0](Arg0: &mut StakedSui)
17MutBorrowField[15](StakedSui.principal: Balance<SUI>)
18MoveLoc[2](loc0: Balance<SUI>)
19Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
20Pop
21Ret
}
public is_equal_staking_metadata(Arg0: &StakedSui, Arg1: &StakedSui): bool {
L2: loc0: bool
B0:
0CopyLoc[0](Arg0: &StakedSui)
1ImmBorrowField[8](StakedSui.pool_id: ID)
2ReadRef
3CopyLoc[1](Arg1: &StakedSui)
4ImmBorrowField[8](StakedSui.pool_id: ID)
5ReadRef
6Eq
7BrFalse(17)
B1:
8MoveLoc[0](Arg0: &StakedSui)
9ImmBorrowField[1](StakedSui.stake_activation_epoch: u64)
10ReadRef
11MoveLoc[1](Arg1: &StakedSui)
12ImmBorrowField[1](StakedSui.stake_activation_epoch: u64)
13ReadRef
14Eq
15StLoc[2](loc0: bool)
16Branch(23)
B2:
17MoveLoc[0](Arg0: &StakedSui)
18Pop
19MoveLoc[1](Arg1: &StakedSui)
20Pop
21LdFalse
22StLoc[2](loc0: bool)
B3:
23MoveLoc[2](loc0: bool)
24Ret
}
public pool_token_exchange_rate_at_epoch(Arg0: &StakingPool, Arg1: u64): PoolTokenExchangeRate {
L2: loc0: u64
L3: loc1: u64
B0:
0CopyLoc[0](Arg0: &StakingPool)
1CopyLoc[1](Arg1: u64)
2Call is_preactive_at_epoch(&StakingPool, u64): bool
3BrFalse(8)
B1:
4MoveLoc[0](Arg0: &StakingPool)
5Pop
6Call initial_exchange_rate(): PoolTokenExchangeRate
7Ret
B2:
8CopyLoc[0](Arg0: &StakingPool)
9ImmBorrowField[13](StakingPool.deactivation_epoch: Option<u64>)
10CopyLoc[1](Arg1: u64)
11Call option::get_with_default<u64>(&Option<u64>, u64): u64
12MoveLoc[1](Arg1: u64)
13Call u64::min(u64, u64): u64
14StLoc[3](loc1: u64)
15CopyLoc[0](Arg0: &StakingPool)
16ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
17Call option::borrow<u64>(&Option<u64>): &u64
18ReadRef
19StLoc[2](loc0: u64)
B3:
20CopyLoc[3](loc1: u64)
21CopyLoc[2](loc0: u64)
22Ge
23BrFalse(41)
B4:
24CopyLoc[0](Arg0: &StakingPool)
25ImmBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
26CopyLoc[3](loc1: u64)
27Call table::contains<u64, PoolTokenExchangeRate>(&Table<u64, PoolTokenExchangeRate>, u64): bool
28BrFalse(36)
B5:
29Branch(30)
B6:
30MoveLoc[0](Arg0: &StakingPool)
31ImmBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
32MoveLoc[3](loc1: u64)
33Call table::borrow<u64, PoolTokenExchangeRate>(&Table<u64, PoolTokenExchangeRate>, u64): &PoolTokenExchangeRate
34ReadRef
35Ret
B7:
36MoveLoc[3](loc1: u64)
37LdU64(1)
38Sub
39StLoc[3](loc1: u64)
40Branch(20)
B8:
41MoveLoc[0](Arg0: &StakingPool)
42Pop
43Call initial_exchange_rate(): PoolTokenExchangeRate
44Ret
}
public pending_stake_amount(Arg0: &StakingPool): u64 {
B0:
0MoveLoc[0](Arg0: &StakingPool)
1ImmBorrowField[0](StakingPool.pending_stake: u64)
2ReadRef
3Ret
}
public pending_stake_withdraw_amount(Arg0: &StakingPool): u64 {
B0:
0MoveLoc[0](Arg0: &StakingPool)
1ImmBorrowField[2](StakingPool.pending_total_sui_withdraw: u64)
2ReadRef
3Ret
}
public(friend) exchange_rates(Arg0: &StakingPool): &Table<u64, PoolTokenExchangeRate> {
B0:
0MoveLoc[0](Arg0: &StakingPool)
1ImmBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
2Ret
}
public sui_amount(Arg0: &PoolTokenExchangeRate): u64 {
B0:
0MoveLoc[0](Arg0: &PoolTokenExchangeRate)
1ImmBorrowField[17](PoolTokenExchangeRate.sui_amount: u64)
2ReadRef
3Ret
}
public pool_token_amount(Arg0: &PoolTokenExchangeRate): u64 {
B0:
0MoveLoc[0](Arg0: &PoolTokenExchangeRate)
1ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
2ReadRef
3Ret
}
is_preactive_at_epoch(Arg0: &StakingPool, Arg1: u64): bool {
L2: loc0: bool
B0:
0CopyLoc[0](Arg0: &StakingPool)
1Call is_preactive(&StakingPool): bool
2BrFalse(8)
B1:
3MoveLoc[0](Arg0: &StakingPool)
4Pop
5LdTrue
6StLoc[2](loc0: bool)
7Branch(15)
B2:
8MoveLoc[0](Arg0: &StakingPool)
9ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
10Call option::borrow<u64>(&Option<u64>): &u64
11ReadRef
12MoveLoc[1](Arg1: u64)
13Gt
14StLoc[2](loc0: bool)
B3:
15MoveLoc[2](loc0: bool)
16Ret
}
get_sui_amount(Arg0: &PoolTokenExchangeRate, Arg1: u64): u64 {
L2: loc0: bool
B0:
0CopyLoc[0](Arg0: &PoolTokenExchangeRate)
1ImmBorrowField[17](PoolTokenExchangeRate.sui_amount: u64)
2ReadRef
3LdU64(0)
4Eq
5BrFalse(9)
B1:
6LdTrue
7StLoc[2](loc0: bool)
8Branch(15)
B2:
9CopyLoc[0](Arg0: &PoolTokenExchangeRate)
10ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
11ReadRef
12LdU64(0)
13Eq
14StLoc[2](loc0: bool)
B3:
15MoveLoc[2](loc0: bool)
16BrFalse(21)
B4:
17MoveLoc[0](Arg0: &PoolTokenExchangeRate)
18Pop
19MoveLoc[1](Arg1: u64)
20Ret
B5:
21CopyLoc[0](Arg0: &PoolTokenExchangeRate)
22ImmBorrowField[17](PoolTokenExchangeRate.sui_amount: u64)
23ReadRef
24CastU128
25MoveLoc[1](Arg1: u64)
26CastU128
27Mul
28MoveLoc[0](Arg0: &PoolTokenExchangeRate)
29ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
30ReadRef
31CastU128
32Div
33CastU64
34Ret
}
get_token_amount(Arg0: &PoolTokenExchangeRate, Arg1: u64): u64 {
L2: loc0: bool
B0:
0CopyLoc[0](Arg0: &PoolTokenExchangeRate)
1ImmBorrowField[17](PoolTokenExchangeRate.sui_amount: u64)
2ReadRef
3LdU64(0)
4Eq
5BrFalse(9)
B1:
6LdTrue
7StLoc[2](loc0: bool)
8Branch(15)
B2:
9CopyLoc[0](Arg0: &PoolTokenExchangeRate)
10ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
11ReadRef
12LdU64(0)
13Eq
14StLoc[2](loc0: bool)
B3:
15MoveLoc[2](loc0: bool)
16BrFalse(21)
B4:
17MoveLoc[0](Arg0: &PoolTokenExchangeRate)
18Pop
19MoveLoc[1](Arg1: u64)
20Ret
B5:
21CopyLoc[0](Arg0: &PoolTokenExchangeRate)
22ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
23ReadRef
24CastU128
25MoveLoc[1](Arg1: u64)
26CastU128
27Mul
28MoveLoc[0](Arg0: &PoolTokenExchangeRate)
29ImmBorrowField[17](PoolTokenExchangeRate.sui_amount: u64)
30ReadRef
31CastU128
32Div
33CastU64
34Ret
}
initial_exchange_rate(): PoolTokenExchangeRate {
B0:
0LdU64(0)
1LdU64(0)
2Pack[1](PoolTokenExchangeRate)
3Ret
}
check_balance_invariants(Arg0: &StakingPool, Arg1: u64) {
L2: loc0: u64
L3: loc1: PoolTokenExchangeRate
L4: loc2: u64
B0:
0CopyLoc[0](Arg0: &StakingPool)
1MoveLoc[1](Arg1: u64)
2Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
3StLoc[3](loc1: PoolTokenExchangeRate)
4ImmBorrowLoc[3](loc1: PoolTokenExchangeRate)
5CopyLoc[0](Arg0: &StakingPool)
6ImmBorrowField[9](StakingPool.sui_balance: u64)
7ReadRef
8Call get_token_amount(&PoolTokenExchangeRate, u64): u64
9StLoc[4](loc2: u64)
10MoveLoc[0](Arg0: &StakingPool)
11ImmBorrowField[11](StakingPool.pool_token_balance: u64)
12ReadRef
13StLoc[2](loc0: u64)
14MoveLoc[4](loc2: u64)
15MoveLoc[2](loc0: u64)
16Eq
17BrFalse(19)
B1:
18Branch(21)
B2:
19LdConst[10](u64: 9)
20Abort
B3:
21Ret
}
public(friend) calculate_rewards(Arg0: &StakingPool, Arg1: &StakedSui, Arg2: u64): u64 {
L3: loc0: u64
L4: loc1: PoolTokenExchangeRate
L5: loc2: PoolTokenExchangeRate
L6: loc3: u64
L7: loc4: u64
L8: loc5: u64
B0:
0CopyLoc[1](Arg1: &StakedSui)
1Call staked_sui_amount(&StakedSui): u64
2StLoc[7](loc4: u64)
3CopyLoc[0](Arg0: &StakingPool)
4MoveLoc[1](Arg1: &StakedSui)
5ImmBorrowField[1](StakedSui.stake_activation_epoch: u64)
6ReadRef
7Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
8StLoc[4](loc1: PoolTokenExchangeRate)
9ImmBorrowLoc[4](loc1: PoolTokenExchangeRate)
10CopyLoc[7](loc4: u64)
11Call get_token_amount(&PoolTokenExchangeRate, u64): u64
12StLoc[6](loc3: u64)
13CopyLoc[0](Arg0: &StakingPool)
14MoveLoc[2](Arg2: u64)
15Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
16StLoc[5](loc2: PoolTokenExchangeRate)
17ImmBorrowLoc[5](loc2: PoolTokenExchangeRate)
18MoveLoc[6](loc3: u64)
19Call get_sui_amount(&PoolTokenExchangeRate, u64): u64
20StLoc[8](loc5: u64)
21CopyLoc[8](loc5: u64)
22CopyLoc[7](loc4: u64)
23Ge
24BrFalse(30)
B1:
25MoveLoc[8](loc5: u64)
26MoveLoc[7](loc4: u64)
27Sub
28StLoc[3](loc0: u64)
29Branch(32)
B2:
30LdU64(0)
31StLoc[3](loc0: u64)
B3:
32MoveLoc[3](loc0: u64)
33MoveLoc[0](Arg0: &StakingPool)
34ImmBorrowField[7](StakingPool.rewards_pool: Balance<SUI>)
35Call balance::value<SUI>(&Balance<SUI>): u64
36Call u64::min(u64, u64): u64
37Ret
}
Constants [
0 => u64: 1000000000
1 => u64: 0
2 => u64: 1
3 => u64: 2
4 => u64: 3
5 => u64: 4
6 => u64: 5
7 => u64: 6
8 => u64: 7
9 => u64: 8
10 => u64: 9
11 => u64: 10
12 => u64: 11
13 => u64: 12
14 => u64: 13
15 => u64: 14
16 => u64: 15
17 => u64: 16
18 => u64: 17
19 => u64: 18
20 => u64: 19
21 => u64: 20
]
}