staking_pool

Module0x9193…6edc

Move path: 0x9193…6edc::staking_pool
Functions: 3621 public, 0 entry
Structs: 3
Friend modules: claim staking staking_admin

staking_pool

Bytecode940 lines

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

// Move bytecode v6

module 9193d45dad53d69b83728cc015e398196fc7a35c06f1e758dfd5f71c51cf6edc.staking_pool {

use 9193d45dad53d69b83728cc015e398196fc7a35c06f1e758dfd5f71c51cf6edc::admin;

use 9193d45dad53d69b83728cc015e398196fc7a35c06f1e758dfd5f71c51cf6edc::math;

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct STAKING_POOL has drop {

dummy_field: bool

}

struct StakingPool<phantom Ty0> has store, key {

id: UID,

rewards_balance: Balance<Ty0>,

staked: Balance<Ty0>,

reward_amount: u64,

harvested_amount: u64,

total_weight: u128,

index: u128,

last_harvest_time: u64,

reward_end_time: u64,

chakra_multipliers: vector<u64>,

min_lock_time: u64,

max_lock_time: u64,

lock_durations: vector<u64>,

max_time_multiplier: u64,

enabled: bool

}

struct StakedPosition<phantom Ty0> has store, key {

id: UID,

pool_id: ID,

stake_amount: u64,

stake_weight: u128,

time_multiplier: u64,

chakra_multiplier: u64,

net_multiplier: u64,

index: u128,

start_time: u64,

end_time: u64,

last_updated_time: u64,

harvested_rewards: u64

}

init(Arg0: STAKING_POOL, Arg1: &mut TxContext) {

B0:

0MoveLoc[0](Arg0: STAKING_POOL)

1CopyLoc[1](Arg1: &mut TxContext)

2Call package::claim<STAKING_POOL>(STAKING_POOL, &mut TxContext): Publisher

3MoveLoc[1](Arg1: &mut TxContext)

4FreezeRef

5Call tx_context::sender(&TxContext): address

6Call transfer::public_transfer<Publisher>(Publisher, address)

7Ret

}

public(friend) create_pool<Ty0>(Arg0: &AdminCap, Arg1: Coin<Ty0>, Arg2: &Clock, Arg3: &mut TxContext) {

B0:

0MoveLoc[3](Arg3: &mut TxContext)

1Call object::new(&mut TxContext): UID

2Call balance::zero<Ty0>(): Balance<Ty0>

3MoveLoc[1](Arg1: Coin<Ty0>)

4Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>

5LdU64(0)

6LdU64(0)

7LdU128(0)

8LdU128(0)

9MoveLoc[2](Arg2: &Clock)

10Call clock::timestamp_ms(&Clock): u64

11LdU64(0)

12VecPack(20, 0)

13LdU64(0)

14LdU64(0)

15VecPack(20, 0)

16LdU64(0)

17LdFalse

18PackGeneric[0](StakingPool<Ty0>)

19Call transfer::share_object<StakingPool<Ty0>>(StakingPool<Ty0>)

20Ret

}

public(friend) set_enabled<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: bool) {

B0:

0MoveLoc[2](Arg2: bool)

1MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

2MutBorrowFieldGeneric[0](StakingPool.enabled: bool)

3WriteRef

4Ret

}

public(friend) refill_pool<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: Coin<Ty0>, Arg3: &Clock) {

B0:

0CopyLoc[1](Arg1: &mut StakingPool<Ty0>)

1MoveLoc[3](Arg3: &Clock)

2Call harvest<Ty0>(&mut StakingPool<Ty0>, &Clock)

3CopyLoc[1](Arg1: &mut StakingPool<Ty0>)

4ImmBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

5ReadRef

6ImmBorrowLoc[2](Arg2: Coin<Ty0>)

7Call coin::value<Ty0>(&Coin<Ty0>): u64

8Add

9CopyLoc[1](Arg1: &mut StakingPool<Ty0>)

10MutBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

11WriteRef

12MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

13MutBorrowFieldGeneric[2](StakingPool.rewards_balance: Balance<Ty0>)

14MoveLoc[2](Arg2: Coin<Ty0>)

15Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>

16Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64

17Pop

18Ret

}

public(friend) set_reward_end_time<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: u64, Arg3: &Clock) {

B0:

0CopyLoc[1](Arg1: &mut StakingPool<Ty0>)

1MoveLoc[3](Arg3: &Clock)

2Call harvest<Ty0>(&mut StakingPool<Ty0>, &Clock)

3MoveLoc[2](Arg2: u64)

4MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

5MutBorrowFieldGeneric[3](StakingPool.reward_end_time: u64)

6WriteRef

7Ret

}

public(friend) set_min_lock_time<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: u64) {

B0:

0MoveLoc[2](Arg2: u64)

1MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

2MutBorrowFieldGeneric[4](StakingPool.min_lock_time: u64)

3WriteRef

4Ret

}

public(friend) set_max_lock_time<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: u64) {

B0:

0MoveLoc[2](Arg2: u64)

1MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

2MutBorrowFieldGeneric[5](StakingPool.max_lock_time: u64)

3WriteRef

4Ret

}

public(friend) set_max_time_multiplier<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: u64) {

B0:

0MoveLoc[2](Arg2: u64)

1MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

2MutBorrowFieldGeneric[6](StakingPool.max_time_multiplier: u64)

3WriteRef

4Ret

}

public(friend) set_chakra_multipliers<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: vector<u64>) {

B0:

0MoveLoc[2](Arg2: vector<u64>)

1MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

2MutBorrowFieldGeneric[7](StakingPool.chakra_multipliers: vector<u64>)

3WriteRef

4Ret

}

public(friend) set_lock_durations<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: vector<u64>) {

B0:

0MoveLoc[2](Arg2: vector<u64>)

1MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

2MutBorrowFieldGeneric[8](StakingPool.lock_durations: vector<u64>)

3WriteRef

4Ret

}

public(friend) set_reward_amount<Ty0>(Arg0: &AdminCap, Arg1: &mut StakingPool<Ty0>, Arg2: u64) {

B0:

0MoveLoc[2](Arg2: u64)

1MoveLoc[1](Arg1: &mut StakingPool<Ty0>)

2MutBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

3WriteRef

4Ret

}

public(friend) stake<Ty0>(Arg0: &mut StakingPool<Ty0>, Arg1: Coin<Ty0>, Arg2: u64, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext): StakedPosition<Ty0> {

L6: loc0: u64

L7: loc1: u64

L8: loc2: u64

L9: loc3: u128

L10: loc4: u64

B0:

0CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

1FreezeRef

2Call assert_pool_enabled<Ty0>(&StakingPool<Ty0>)

3ImmBorrowLoc[1](Arg1: Coin<Ty0>)

4Call coin::value<Ty0>(&Coin<Ty0>): u64

5LdU64(0)

6Gt

7BrFalse(9)

B1:

8Branch(17)

B2:

9MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

10Pop

11MoveLoc[5](Arg5: &mut TxContext)

12Pop

13MoveLoc[4](Arg4: &Clock)

14Pop

15LdConst[2](u64: 1)

16Abort

B3:

17CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

18FreezeRef

19CopyLoc[2](Arg2: u64)

20Call is_valid_duration<Ty0>(&StakingPool<Ty0>, u64): bool

21BrFalse(23)

B4:

22Branch(31)

B5:

23MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

24Pop

25MoveLoc[5](Arg5: &mut TxContext)

26Pop

27MoveLoc[4](Arg4: &Clock)

28Pop

29LdConst[3](u64: 2)

30Abort

B6:

31CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

32FreezeRef

33CopyLoc[3](Arg3: u64)

34Call is_valid_chakra_level<Ty0>(&StakingPool<Ty0>, u64): bool

35BrFalse(37)

B7:

36Branch(45)

B8:

37MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

38Pop

39MoveLoc[5](Arg5: &mut TxContext)

40Pop

41MoveLoc[4](Arg4: &Clock)

42Pop

43LdConst[4](u64: 3)

44Abort

B9:

45CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

46CopyLoc[4](Arg4: &Clock)

47Call harvest<Ty0>(&mut StakingPool<Ty0>, &Clock)

48ImmBorrowLoc[1](Arg1: Coin<Ty0>)

49Call coin::value<Ty0>(&Coin<Ty0>): u64

50CopyLoc[2](Arg2: u64)

51CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

52ImmBorrowFieldGeneric[4](StakingPool.min_lock_time: u64)

53ReadRef

54CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

55ImmBorrowFieldGeneric[5](StakingPool.max_lock_time: u64)

56ReadRef

57CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

58ImmBorrowFieldGeneric[6](StakingPool.max_time_multiplier: u64)

59ReadRef

60CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

61ImmBorrowFieldGeneric[7](StakingPool.chakra_multipliers: vector<u64>)

62CopyLoc[3](Arg3: u64)

63VecImmBorrow(20)

64ReadRef

65Call math::compute_stake_weight(u64, u64, u64, u64, u64, u64): u128 * u64 * u64

66StLoc[10](loc4: u64)

67StLoc[6](loc0: u64)

68StLoc[9](loc3: u128)

69ImmBorrowLoc[1](Arg1: Coin<Ty0>)

70Call coin::value<Ty0>(&Coin<Ty0>): u64

71StLoc[8](loc2: u64)

72CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

73MutBorrowFieldGeneric[9](StakingPool.staked: Balance<Ty0>)

74MoveLoc[1](Arg1: Coin<Ty0>)

75Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>

76Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64

77Pop

78CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

79ImmBorrowFieldGeneric[10](StakingPool.total_weight: u128)

80ReadRef

81CopyLoc[9](loc3: u128)

82Add

83CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

84MutBorrowFieldGeneric[10](StakingPool.total_weight: u128)

85WriteRef

86MoveLoc[4](Arg4: &Clock)

87Call clock::timestamp_ms(&Clock): u64

88StLoc[7](loc1: u64)

89MoveLoc[5](Arg5: &mut TxContext)

90Call object::new(&mut TxContext): UID

91CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

92FreezeRef

93Call object::id<StakingPool<Ty0>>(&StakingPool<Ty0>): ID

94MoveLoc[8](loc2: u64)

95MoveLoc[9](loc3: u128)

96MoveLoc[10](loc4: u64)

97CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

98ImmBorrowFieldGeneric[7](StakingPool.chakra_multipliers: vector<u64>)

99MoveLoc[3](Arg3: u64)

100VecImmBorrow(20)

101ReadRef

102MoveLoc[6](loc0: u64)

103MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

104ImmBorrowFieldGeneric[11](StakingPool.index: u128)

105ReadRef

106CopyLoc[7](loc1: u64)

107CopyLoc[7](loc1: u64)

108MoveLoc[2](Arg2: u64)

109Add

110MoveLoc[7](loc1: u64)

111LdU64(0)

112PackGeneric[1](StakedPosition<Ty0>)

113Ret

}

public(friend) unstake<Ty0>(Arg0: &mut StakingPool<Ty0>, Arg1: StakedPosition<Ty0>, Arg2: &Clock, Arg3: &mut TxContext): Coin<Ty0> * Coin<Ty0> {

L4: loc0: u64

L5: loc1: UID

L6: loc2: u64

L7: loc3: Coin<Ty0>

L8: loc4: u64

L9: loc5: u128

L10: loc6: Balance<Ty0>

B0:

0CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

1FreezeRef

2Call assert_pool_enabled<Ty0>(&StakingPool<Ty0>)

3CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

4FreezeRef

5ImmBorrowLoc[1](Arg1: StakedPosition<Ty0>)

6Call assert_valid_pool<Ty0>(&StakingPool<Ty0>, &StakedPosition<Ty0>)

7CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

8CopyLoc[2](Arg2: &Clock)

9Call harvest<Ty0>(&mut StakingPool<Ty0>, &Clock)

10CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

11FreezeRef

12MutBorrowLoc[1](Arg1: StakedPosition<Ty0>)

13CopyLoc[2](Arg2: &Clock)

14Call harvest_position<Ty0>(&StakingPool<Ty0>, &mut StakedPosition<Ty0>, &Clock)

15CopyLoc[2](Arg2: &Clock)

16Call clock::timestamp_ms(&Clock): u64

17StLoc[6](loc2: u64)

18CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

19MutBorrowLoc[1](Arg1: StakedPosition<Ty0>)

20MoveLoc[2](Arg2: &Clock)

21CopyLoc[3](Arg3: &mut TxContext)

22Call claim<Ty0>(&mut StakingPool<Ty0>, &mut StakedPosition<Ty0>, &Clock, &mut TxContext): Coin<Ty0>

23StLoc[7](loc3: Coin<Ty0>)

24MoveLoc[1](Arg1: StakedPosition<Ty0>)

25UnpackGeneric[1](StakedPosition<Ty0>)

26Pop

27Pop

28StLoc[4](loc0: u64)

29Pop

30Pop

31Pop

32Pop

33Pop

34StLoc[9](loc5: u128)

35StLoc[8](loc4: u64)

36Pop

37StLoc[5](loc1: UID)

38MoveLoc[6](loc2: u64)

39MoveLoc[4](loc0: u64)

40Ge

41BrFalse(43)

B1:

42Branch(49)

B2:

43MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

44Pop

45MoveLoc[3](Arg3: &mut TxContext)

46Pop

47LdConst[1](u64: 0)

48Abort

B3:

49CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

50ImmBorrowFieldGeneric[10](StakingPool.total_weight: u128)

51ReadRef

52MoveLoc[9](loc5: u128)

53Sub

54CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

55MutBorrowFieldGeneric[10](StakingPool.total_weight: u128)

56WriteRef

57MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

58MutBorrowFieldGeneric[9](StakingPool.staked: Balance<Ty0>)

59MoveLoc[8](loc4: u64)

60Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

61StLoc[10](loc6: Balance<Ty0>)

62MoveLoc[5](loc1: UID)

63Call object::delete(UID)

64MoveLoc[10](loc6: Balance<Ty0>)

65MoveLoc[3](Arg3: &mut TxContext)

66Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>

67MoveLoc[7](loc3: Coin<Ty0>)

68Ret

}

public claim<Ty0>(Arg0: &mut StakingPool<Ty0>, Arg1: &mut StakedPosition<Ty0>, Arg2: &Clock, Arg3: &mut TxContext): Coin<Ty0> {

L4: loc0: u64

L5: loc1: &mut Balance<Ty0>

L6: loc2: u64

L7: loc3: Coin<Ty0>

L8: loc4: u64

B0:

0CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

1FreezeRef

2Call assert_pool_enabled<Ty0>(&StakingPool<Ty0>)

3CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

4FreezeRef

5CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

6FreezeRef

7Call assert_valid_pool<Ty0>(&StakingPool<Ty0>, &StakedPosition<Ty0>)

8CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

9CopyLoc[2](Arg2: &Clock)

10Call harvest<Ty0>(&mut StakingPool<Ty0>, &Clock)

11CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

12FreezeRef

13CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

14MoveLoc[2](Arg2: &Clock)

15Call harvest_position<Ty0>(&StakingPool<Ty0>, &mut StakedPosition<Ty0>, &Clock)

16CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

17ImmBorrowFieldGeneric[12](StakedPosition.harvested_rewards: u64)

18ReadRef

19StLoc[8](loc4: u64)

20CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

21ImmBorrowFieldGeneric[2](StakingPool.rewards_balance: Balance<Ty0>)

22Call balance::value<Ty0>(&Balance<Ty0>): u64

23StLoc[6](loc2: u64)

24CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

25MutBorrowFieldGeneric[2](StakingPool.rewards_balance: Balance<Ty0>)

26StLoc[5](loc1: &mut Balance<Ty0>)

27CopyLoc[8](loc4: u64)

28CopyLoc[6](loc2: u64)

29Gt

30BrFalse(34)

B1:

31MoveLoc[6](loc2: u64)

32StLoc[4](loc0: u64)

33Branch(36)

B2:

34MoveLoc[8](loc4: u64)

35StLoc[4](loc0: u64)

B3:

36MoveLoc[5](loc1: &mut Balance<Ty0>)

37MoveLoc[4](loc0: u64)

38Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

39MoveLoc[3](Arg3: &mut TxContext)

40Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>

41StLoc[7](loc3: Coin<Ty0>)

42LdU64(0)

43MoveLoc[1](Arg1: &mut StakedPosition<Ty0>)

44MutBorrowFieldGeneric[12](StakedPosition.harvested_rewards: u64)

45WriteRef

46CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

47ImmBorrowFieldGeneric[13](StakingPool.harvested_amount: u64)

48ReadRef

49ImmBorrowLoc[7](loc3: Coin<Ty0>)

50Call coin::value<Ty0>(&Coin<Ty0>): u64

51Sub

52MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

53MutBorrowFieldGeneric[13](StakingPool.harvested_amount: u64)

54WriteRef

55MoveLoc[7](loc3: Coin<Ty0>)

56Ret

}

public(friend) harvest<Ty0>(Arg0: &mut StakingPool<Ty0>, Arg1: &Clock) {

L2: loc0: u64

L3: loc1: u64

L4: loc2: u64

L5: loc3: &mut u64

L6: loc4: u64

L7: loc5: u64

B0:

0MoveLoc[1](Arg1: &Clock)

1Call clock::timestamp_ms(&Clock): u64

2StLoc[6](loc4: u64)

3CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

4MutBorrowFieldGeneric[14](StakingPool.last_harvest_time: u64)

5StLoc[5](loc3: &mut u64)

6CopyLoc[6](loc4: u64)

7CopyLoc[5](loc3: &mut u64)

8ReadRef

9Eq

10BrFalse(16)

B1:

11MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

12Pop

13MoveLoc[5](loc3: &mut u64)

14Pop

15Ret

B2:

16CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

17ImmBorrowFieldGeneric[10](StakingPool.total_weight: u128)

18ReadRef

19LdU128(0)

20Eq

21BrFalse(28)

B3:

22MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

23Pop

24MoveLoc[6](loc4: u64)

25MoveLoc[5](loc3: &mut u64)

26WriteRef

27Ret

B4:

28CopyLoc[5](loc3: &mut u64)

29ReadRef

30CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

31ImmBorrowFieldGeneric[3](StakingPool.reward_end_time: u64)

32ReadRef

33Gt

34BrFalse(41)

B5:

35MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

36Pop

37MoveLoc[6](loc4: u64)

38MoveLoc[5](loc3: &mut u64)

39WriteRef

40Ret

B6:

41CopyLoc[6](loc4: u64)

42CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

43ImmBorrowFieldGeneric[3](StakingPool.reward_end_time: u64)

44ReadRef

45Gt

46BrFalse(55)

B7:

47CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

48ImmBorrowFieldGeneric[3](StakingPool.reward_end_time: u64)

49ReadRef

50CopyLoc[5](loc3: &mut u64)

51ReadRef

52Sub

53StLoc[2](loc0: u64)

54Branch(60)

B8:

55CopyLoc[6](loc4: u64)

56CopyLoc[5](loc3: &mut u64)

57ReadRef

58Sub

59StLoc[2](loc0: u64)

B9:

60MoveLoc[2](loc0: u64)

61StLoc[4](loc2: u64)

62CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

63ImmBorrowFieldGeneric[3](StakingPool.reward_end_time: u64)

64ReadRef

65CopyLoc[5](loc3: &mut u64)

66ReadRef

67Sub

68StLoc[7](loc5: u64)

69CopyLoc[7](loc5: u64)

70LdU64(0)

71Eq

72BrFalse(79)

B10:

73MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

74Pop

75MoveLoc[6](loc4: u64)

76MoveLoc[5](loc3: &mut u64)

77WriteRef

78Ret

B11:

79MoveLoc[4](loc2: u64)

80CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

81ImmBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

82ReadRef

83MoveLoc[7](loc5: u64)

84Call math::mul_factor(u64, u64, u64): u64

85StLoc[3](loc1: u64)

86CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

87ImmBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

88ReadRef

89CopyLoc[3](loc1: u64)

90Gt

91BrFalse(101)

B12:

92CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

93ImmBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

94ReadRef

95CopyLoc[3](loc1: u64)

96Sub

97CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

98MutBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

99WriteRef

100Branch(105)

B13:

101LdU64(0)

102CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

103MutBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

104WriteRef

B14:

105CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

106ImmBorrowFieldGeneric[13](StakingPool.harvested_amount: u64)

107ReadRef

108CopyLoc[3](loc1: u64)

109Add

110CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

111MutBorrowFieldGeneric[13](StakingPool.harvested_amount: u64)

112WriteRef

113CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

114ImmBorrowFieldGeneric[11](StakingPool.index: u128)

115ReadRef

116MoveLoc[3](loc1: u64)

117CastU128

118LdConst[0](u128: 1844..)

119CopyLoc[0](Arg0: &mut StakingPool<Ty0>)

120ImmBorrowFieldGeneric[10](StakingPool.total_weight: u128)

121ReadRef

122Call math::mul_factor_u128(u128, u128, u128): u128

123Add

124MoveLoc[0](Arg0: &mut StakingPool<Ty0>)

125MutBorrowFieldGeneric[11](StakingPool.index: u128)

126WriteRef

127MoveLoc[6](loc4: u64)

128MoveLoc[5](loc3: &mut u64)

129WriteRef

130Ret

}

public(friend) harvest_position<Ty0>(Arg0: &StakingPool<Ty0>, Arg1: &mut StakedPosition<Ty0>, Arg2: &Clock) {

L3: loc0: bool

L4: loc1: u128

L5: loc2: u64

B0:

0CopyLoc[0](Arg0: &StakingPool<Ty0>)

1Call assert_pool_enabled<Ty0>(&StakingPool<Ty0>)

2MoveLoc[2](Arg2: &Clock)

3Call clock::timestamp_ms(&Clock): u64

4StLoc[5](loc2: u64)

5CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

6ImmBorrowFieldGeneric[15](StakedPosition.stake_weight: u128)

7ReadRef

8LdU128(0)

9Eq

10BrFalse(22)

B1:

11MoveLoc[5](loc2: u64)

12CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

13MutBorrowFieldGeneric[16](StakedPosition.last_updated_time: u64)

14WriteRef

15MoveLoc[0](Arg0: &StakingPool<Ty0>)

16ImmBorrowFieldGeneric[11](StakingPool.index: u128)

17ReadRef

18MoveLoc[1](Arg1: &mut StakedPosition<Ty0>)

19MutBorrowFieldGeneric[17](StakedPosition.index: u128)

20WriteRef

21Ret

B2:

22CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

23ImmBorrowFieldGeneric[17](StakedPosition.index: u128)

24ReadRef

25CopyLoc[0](Arg0: &StakingPool<Ty0>)

26ImmBorrowFieldGeneric[11](StakingPool.index: u128)

27ReadRef

28Eq

29BrFalse(33)

B3:

30LdTrue

31StLoc[3](loc0: bool)

32Branch(41)

B4:

33CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

34ImmBorrowFieldGeneric[16](StakedPosition.last_updated_time: u64)

35ReadRef

36CopyLoc[0](Arg0: &StakingPool<Ty0>)

37ImmBorrowFieldGeneric[14](StakingPool.last_harvest_time: u64)

38ReadRef

39Eq

40StLoc[3](loc0: bool)

B5:

41MoveLoc[3](loc0: bool)

42BrFalse(48)

B6:

43MoveLoc[1](Arg1: &mut StakedPosition<Ty0>)

44Pop

45MoveLoc[0](Arg0: &StakingPool<Ty0>)

46Pop

47Ret

B7:

48CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

49ImmBorrowFieldGeneric[15](StakedPosition.stake_weight: u128)

50ReadRef

51CopyLoc[0](Arg0: &StakingPool<Ty0>)

52ImmBorrowFieldGeneric[11](StakingPool.index: u128)

53ReadRef

54CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

55ImmBorrowFieldGeneric[17](StakedPosition.index: u128)

56ReadRef

57Sub

58LdConst[0](u128: 1844..)

59Call math::mul_factor_u128(u128, u128, u128): u128

60StLoc[4](loc1: u128)

61CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

62ImmBorrowFieldGeneric[12](StakedPosition.harvested_rewards: u64)

63ReadRef

64MoveLoc[4](loc1: u128)

65CastU64

66Add

67CopyLoc[1](Arg1: &mut StakedPosition<Ty0>)

68MutBorrowFieldGeneric[12](StakedPosition.harvested_rewards: u64)

69WriteRef

70MoveLoc[0](Arg0: &StakingPool<Ty0>)

71ImmBorrowFieldGeneric[11](StakingPool.index: u128)

72ReadRef

73MoveLoc[1](Arg1: &mut StakedPosition<Ty0>)

74MutBorrowFieldGeneric[17](StakedPosition.index: u128)

75WriteRef

76Ret

}

public is_valid_duration<Ty0>(Arg0: &StakingPool<Ty0>, Arg1: u64): bool {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[8](StakingPool.lock_durations: vector<u64>)

2ImmBorrowLoc[1](Arg1: u64)

3Call vector::contains<u64>(&vector<u64>, &u64): bool

4Ret

}

public is_valid_chakra_level<Ty0>(Arg0: &StakingPool<Ty0>, Arg1: u64): bool {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[7](StakingPool.chakra_multipliers: vector<u64>)

2VecLen(20)

3MoveLoc[1](Arg1: u64)

4Gt

5Ret

}

public assert_valid_pool<Ty0>(Arg0: &StakingPool<Ty0>, Arg1: &StakedPosition<Ty0>) {

B0:

0MoveLoc[1](Arg1: &StakedPosition<Ty0>)

1ImmBorrowFieldGeneric[18](StakedPosition.pool_id: ID)

2ReadRef

3MoveLoc[0](Arg0: &StakingPool<Ty0>)

4Call object::id<StakingPool<Ty0>>(&StakingPool<Ty0>): ID

5Eq

6BrFalse(8)

B1:

7Branch(10)

B2:

8LdConst[5](u64: 4)

9Abort

B3:

10Ret

}

public assert_pool_enabled<Ty0>(Arg0: &StakingPool<Ty0>) {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[0](StakingPool.enabled: bool)

2ReadRef

3BrFalse(5)

B1:

4Branch(7)

B2:

5LdConst[6](u64: 5)

6Abort

B3:

7Ret

}

public is_pool_enabled<Ty0>(Arg0: &StakingPool<Ty0>): bool {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[0](StakingPool.enabled: bool)

2ReadRef

3Ret

}

public total_staked<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[9](StakingPool.staked: Balance<Ty0>)

2Call balance::value<Ty0>(&Balance<Ty0>): u64

3Ret

}

public total_weight<Ty0>(Arg0: &StakingPool<Ty0>): u128 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[10](StakingPool.total_weight: u128)

2ReadRef

3Ret

}

public total_rewards<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[1](StakingPool.reward_amount: u64)

2ReadRef

3Ret

}

public total_harvested<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[13](StakingPool.harvested_amount: u64)

2ReadRef

3Ret

}

public index<Ty0>(Arg0: &StakingPool<Ty0>): u128 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[11](StakingPool.index: u128)

2ReadRef

3Ret

}

public last_update_time<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[14](StakingPool.last_harvest_time: u64)

2ReadRef

3Ret

}

public reward_end_time<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[3](StakingPool.reward_end_time: u64)

2ReadRef

3Ret

}

public min_lock_time<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[4](StakingPool.min_lock_time: u64)

2ReadRef

3Ret

}

public max_lock_time<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[5](StakingPool.max_lock_time: u64)

2ReadRef

3Ret

}

public max_time_multiplier<Ty0>(Arg0: &StakingPool<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[6](StakingPool.max_time_multiplier: u64)

2ReadRef

3Ret

}

public lock_durations<Ty0>(Arg0: &StakingPool<Ty0>): vector<u64> {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[8](StakingPool.lock_durations: vector<u64>)

2ReadRef

3Ret

}

public chakra_multipliers<Ty0>(Arg0: &StakingPool<Ty0>): vector<u64> {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[7](StakingPool.chakra_multipliers: vector<u64>)

2ReadRef

3Ret

}

public get_chakra_multiplier<Ty0>(Arg0: &StakingPool<Ty0>, Arg1: u64): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool<Ty0>)

1ImmBorrowFieldGeneric[7](StakingPool.chakra_multipliers: vector<u64>)

2MoveLoc[1](Arg1: u64)

3VecImmBorrow(20)

4ReadRef

5Ret

}

public position_info<Ty0>(Arg0: &StakedPosition<Ty0>): ID * ID * u64 * u128 * u64 * u64 * u64 * u128 * u64 * u64 * u64 * u64 {

B0:

0CopyLoc[0](Arg0: &StakedPosition<Ty0>)

1Call object::id<StakedPosition<Ty0>>(&StakedPosition<Ty0>): ID

2CopyLoc[0](Arg0: &StakedPosition<Ty0>)

3ImmBorrowFieldGeneric[18](StakedPosition.pool_id: ID)

4ReadRef

5CopyLoc[0](Arg0: &StakedPosition<Ty0>)

6ImmBorrowFieldGeneric[19](StakedPosition.stake_amount: u64)

7ReadRef

8CopyLoc[0](Arg0: &StakedPosition<Ty0>)

9ImmBorrowFieldGeneric[15](StakedPosition.stake_weight: u128)

10ReadRef

11CopyLoc[0](Arg0: &StakedPosition<Ty0>)

12ImmBorrowFieldGeneric[20](StakedPosition.time_multiplier: u64)

13ReadRef

14CopyLoc[0](Arg0: &StakedPosition<Ty0>)

15ImmBorrowFieldGeneric[21](StakedPosition.chakra_multiplier: u64)

16ReadRef

17CopyLoc[0](Arg0: &StakedPosition<Ty0>)

18ImmBorrowFieldGeneric[22](StakedPosition.net_multiplier: u64)

19ReadRef

20CopyLoc[0](Arg0: &StakedPosition<Ty0>)

21ImmBorrowFieldGeneric[17](StakedPosition.index: u128)

22ReadRef

23CopyLoc[0](Arg0: &StakedPosition<Ty0>)

24ImmBorrowFieldGeneric[23](StakedPosition.start_time: u64)

25ReadRef

26CopyLoc[0](Arg0: &StakedPosition<Ty0>)

27ImmBorrowFieldGeneric[24](StakedPosition.end_time: u64)

28ReadRef

29CopyLoc[0](Arg0: &StakedPosition<Ty0>)

30ImmBorrowFieldGeneric[16](StakedPosition.last_updated_time: u64)

31ReadRef

32MoveLoc[0](Arg0: &StakedPosition<Ty0>)

33ImmBorrowFieldGeneric[12](StakedPosition.harvested_rewards: u64)

34ReadRef

35Ret

}

public position_weight<Ty0>(Arg0: &StakedPosition<Ty0>): u128 {

B0:

0MoveLoc[0](Arg0: &StakedPosition<Ty0>)

1ImmBorrowFieldGeneric[15](StakedPosition.stake_weight: u128)

2ReadRef

3Ret

}

Constants [

0 => u128: 18446744073709551616

1 => u64: 0

2 => u64: 1

3 => u64: 2

4 => u64: 3

5 => u64: 4

6 => u64: 5

]

}