well

Module0xae5f…6600

Move path: 0xce7f…4db2::well
Functions: 1916 public, 0 entry
Structs: 3
Friend modules: buck

well

Bytecode563 lines

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

// Move bytecode v7

module ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2.well {

use 00db9a10bb9536ab367b7d1ffa404c1d6c55f009076df1139dc108dd86608bbe::math;

use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::bkt;

use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::constants;

use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::well_events;

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Well<phantom Ty0> has store, key {

id: UID,

shared_pool: Balance<Ty0>,

reserve: Balance<Ty0>,

staked: Balance<BKT>,

total_weight: u64,

current_s: u128

}

struct StakedBKT<phantom Ty0> has store, key {

id: UID,

stake_amount: u64,

start_s: u128,

stake_weight: u64,

lock_until: u64

}

struct WELL has drop {

dummy_field: bool

}

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

B0:

0MoveLoc[0](Arg0: WELL)

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

2Call package::claim<WELL>(WELL, &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) new<Ty0>(Arg0: &mut TxContext): Well<Ty0> {

B0:

0MoveLoc[0](Arg0: &mut TxContext)

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

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

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

4Call balance::zero<BKT>(): Balance<BKT>

5LdU64(0)

6LdU128(0)

7PackGeneric[0](Well<Ty0>)

8Ret

}

public collect_fee<Ty0>(Arg0: &mut Well<Ty0>, Arg1: Balance<Ty0>) {

L2: loc0: bool

L3: loc1: u64

L4: loc2: u64

L5: loc3: Balance<Ty0>

B0:

0ImmBorrowLoc[1](Arg1: Balance<Ty0>)

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

2StLoc[3](loc1: u64)

3CopyLoc[3](loc1: u64)

4Call well_events::emit_collect_fee<Ty0>(u64)

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

6ImmBorrowFieldGeneric[0](Well.total_weight: u64)

7ReadRef

8LdU64(0)

9Gt

10BrFalse(16)

B1:

11CopyLoc[3](loc1: u64)

12LdU64(100)

13Ge

14StLoc[2](loc0: bool)

15Branch(18)

B2:

16LdFalse

17StLoc[2](loc0: bool)

B3:

18MoveLoc[2](loc0: bool)

19BrFalse(55)

B4:

20MutBorrowLoc[1](Arg1: Balance<Ty0>)

21MoveLoc[3](loc1: u64)

22LdU64(100)

23Div

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

25StLoc[5](loc3: Balance<Ty0>)

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

27MutBorrowFieldGeneric[1](Well.reserve: Balance<Ty0>)

28MoveLoc[5](loc3: Balance<Ty0>)

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

30Pop

31ImmBorrowLoc[1](Arg1: Balance<Ty0>)

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

33StLoc[4](loc2: u64)

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

35MutBorrowFieldGeneric[2](Well.shared_pool: Balance<Ty0>)

36MoveLoc[1](Arg1: Balance<Ty0>)

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

38Pop

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

40ImmBorrowFieldGeneric[3](Well.current_s: u128)

41ReadRef

42MoveLoc[4](loc2: u64)

43CastU128

44Call constants::distribution_precision(): u128

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

46ImmBorrowFieldGeneric[0](Well.total_weight: u64)

47ReadRef

48CastU128

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

50Add

51MoveLoc[0](Arg0: &mut Well<Ty0>)

52MutBorrowFieldGeneric[3](Well.current_s: u128)

53WriteRef

54Branch(60)

B5:

55MoveLoc[0](Arg0: &mut Well<Ty0>)

56MutBorrowFieldGeneric[1](Well.reserve: Balance<Ty0>)

57MoveLoc[1](Arg1: Balance<Ty0>)

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

59Pop

B6:

60Ret

}

public collect_fee_from<Ty0>(Arg0: &mut Well<Ty0>, Arg1: Balance<Ty0>, Arg2: String) {

B0:

0ImmBorrowLoc[1](Arg1: Balance<Ty0>)

1MoveLoc[2](Arg2: String)

2Call ascii::into_bytes(String): vector<u8>

3Call well_events::emit_collect_fee_from<Ty0>(&Balance<Ty0>, vector<u8>)

4MoveLoc[0](Arg0: &mut Well<Ty0>)

5MoveLoc[1](Arg1: Balance<Ty0>)

6Call collect_fee<Ty0>(&mut Well<Ty0>, Balance<Ty0>)

7Ret

}

public airdrop<Ty0>(Arg0: &mut Well<Ty0>, Arg1: Balance<Ty0>) {

B0:

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

1MutBorrowFieldGeneric[2](Well.shared_pool: Balance<Ty0>)

2MoveLoc[1](Arg1: Balance<Ty0>)

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

4Pop

5Ret

}

public stake<Ty0>(Arg0: &Clock, Arg1: &mut Well<Ty0>, Arg2: Balance<BKT>, Arg3: u64, Arg4: &mut TxContext): StakedBKT<Ty0> {

L5: loc0: u64

L6: loc1: u64

B0:

0ImmBorrowLoc[2](Arg2: Balance<BKT>)

1Call balance::value<BKT>(&Balance<BKT>): u64

2StLoc[5](loc0: u64)

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

4MutBorrowFieldGeneric[4](Well.staked: Balance<BKT>)

5MoveLoc[2](Arg2: Balance<BKT>)

6Call balance::join<BKT>(&mut Balance<BKT>, Balance<BKT>): u64

7Pop

8CopyLoc[5](loc0: u64)

9CopyLoc[3](Arg3: u64)

10Call compute_weight(u64, u64): u64

11StLoc[6](loc1: u64)

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

13ImmBorrowFieldGeneric[0](Well.total_weight: u64)

14ReadRef

15CopyLoc[6](loc1: u64)

16Add

17CopyLoc[1](Arg1: &mut Well<Ty0>)

18MutBorrowFieldGeneric[0](Well.total_weight: u64)

19WriteRef

20CopyLoc[5](loc0: u64)

21CopyLoc[6](loc1: u64)

22CopyLoc[3](Arg3: u64)

23Call well_events::emit_stake<Ty0>(u64, u64, u64)

24MoveLoc[4](Arg4: &mut TxContext)

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

26MoveLoc[5](loc0: u64)

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

28ImmBorrowFieldGeneric[3](Well.current_s: u128)

29ReadRef

30MoveLoc[6](loc1: u64)

31MoveLoc[0](Arg0: &Clock)

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

33MoveLoc[3](Arg3: u64)

34Add

35PackGeneric[1](StakedBKT<Ty0>)

36Ret

}

public unstake<Ty0>(Arg0: &Clock, Arg1: &mut Well<Ty0>, Arg2: StakedBKT<Ty0>): Balance<BKT> * Balance<Ty0> {

L3: loc0: &StakedBKT<Ty0>

L4: loc1: UID

L5: loc2: u64

L6: loc3: u64

L7: loc4: u64

L8: loc5: u64

B0:

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

1ImmBorrowLoc[2](Arg2: StakedBKT<Ty0>)

2StLoc[3](loc0: &StakedBKT<Ty0>)

3FreezeRef

4MoveLoc[3](loc0: &StakedBKT<Ty0>)

5Call get_reward_amount<Ty0>(&Well<Ty0>, &StakedBKT<Ty0>): u64

6StLoc[6](loc3: u64)

7MoveLoc[2](Arg2: StakedBKT<Ty0>)

8UnpackGeneric[1](StakedBKT<Ty0>)

9StLoc[5](loc2: u64)

10StLoc[8](loc5: u64)

11Pop

12StLoc[7](loc4: u64)

13StLoc[4](loc1: UID)

14MoveLoc[0](Arg0: &Clock)

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

16MoveLoc[5](loc2: u64)

17Ge

18BrFalse(20)

B1:

19Branch(24)

B2:

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

21Pop

22LdConst[0](u64: 0)

23Abort

B3:

24MoveLoc[4](loc1: UID)

25Call object::delete(UID)

26CopyLoc[1](Arg1: &mut Well<Ty0>)

27ImmBorrowFieldGeneric[0](Well.total_weight: u64)

28ReadRef

29CopyLoc[8](loc5: u64)

30Sub

31CopyLoc[1](Arg1: &mut Well<Ty0>)

32MutBorrowFieldGeneric[0](Well.total_weight: u64)

33WriteRef

34CopyLoc[7](loc4: u64)

35MoveLoc[8](loc5: u64)

36CopyLoc[6](loc3: u64)

37Call well_events::emit_unstake<Ty0>(u64, u64, u64)

38CopyLoc[1](Arg1: &mut Well<Ty0>)

39MutBorrowFieldGeneric[4](Well.staked: Balance<BKT>)

40MoveLoc[7](loc4: u64)

41Call balance::split<BKT>(&mut Balance<BKT>, u64): Balance<BKT>

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

43MutBorrowFieldGeneric[2](Well.shared_pool: Balance<Ty0>)

44MoveLoc[6](loc3: u64)

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

46Ret

}

public force_unstake<Ty0>(Arg0: &Clock, Arg1: &mut Well<Ty0>, Arg2: &mut BktTreasury, Arg3: StakedBKT<Ty0>): Balance<BKT> * Balance<Ty0> {

L4: loc0: &StakedBKT<Ty0>

L5: loc1: u64

L6: loc2: UID

L7: loc3: u64

L8: loc4: Balance<BKT>

L9: loc5: u64

L10: loc6: u64

L11: loc7: u64

L12: loc8: u64

L13: loc9: u64

B0:

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

1ImmBorrowLoc[3](Arg3: StakedBKT<Ty0>)

2StLoc[4](loc0: &StakedBKT<Ty0>)

3FreezeRef

4MoveLoc[4](loc0: &StakedBKT<Ty0>)

5Call get_reward_amount<Ty0>(&Well<Ty0>, &StakedBKT<Ty0>): u64

6StLoc[11](loc7: u64)

7MoveLoc[0](Arg0: &Clock)

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

9StLoc[5](loc1: u64)

10ImmBorrowLoc[3](Arg3: StakedBKT<Ty0>)

11CopyLoc[5](loc1: u64)

12Call get_token_penalty_amount<Ty0>(&StakedBKT<Ty0>, u64): u64

13StLoc[9](loc5: u64)

14MoveLoc[3](Arg3: StakedBKT<Ty0>)

15UnpackGeneric[1](StakedBKT<Ty0>)

16StLoc[7](loc3: u64)

17StLoc[13](loc9: u64)

18Pop

19StLoc[12](loc8: u64)

20StLoc[6](loc2: UID)

21MoveLoc[5](loc1: u64)

22MoveLoc[7](loc3: u64)

23Lt

24BrFalse(26)

B1:

25Branch(32)

B2:

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

27Pop

28MoveLoc[2](Arg2: &mut BktTreasury)

29Pop

30LdConst[1](u64: 1)

31Abort

B3:

32MoveLoc[6](loc2: UID)

33Call object::delete(UID)

34CopyLoc[9](loc5: u64)

35Call well_events::emit_penalty<Ty0>(u64)

36CopyLoc[1](Arg1: &mut Well<Ty0>)

37MutBorrowFieldGeneric[4](Well.staked: Balance<BKT>)

38CopyLoc[9](loc5: u64)

39Call balance::split<BKT>(&mut Balance<BKT>, u64): Balance<BKT>

40StLoc[8](loc4: Balance<BKT>)

41MoveLoc[2](Arg2: &mut BktTreasury)

42MoveLoc[8](loc4: Balance<BKT>)

43Call bkt::collect_bkt(&mut BktTreasury, Balance<BKT>)

44CopyLoc[12](loc8: u64)

45MoveLoc[9](loc5: u64)

46Sub

47StLoc[10](loc6: u64)

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

49ImmBorrowFieldGeneric[0](Well.total_weight: u64)

50ReadRef

51CopyLoc[13](loc9: u64)

52Sub

53CopyLoc[1](Arg1: &mut Well<Ty0>)

54MutBorrowFieldGeneric[0](Well.total_weight: u64)

55WriteRef

56MoveLoc[12](loc8: u64)

57MoveLoc[13](loc9: u64)

58CopyLoc[11](loc7: u64)

59Call well_events::emit_unstake<Ty0>(u64, u64, u64)

60CopyLoc[1](Arg1: &mut Well<Ty0>)

61MutBorrowFieldGeneric[4](Well.staked: Balance<BKT>)

62MoveLoc[10](loc6: u64)

63Call balance::split<BKT>(&mut Balance<BKT>, u64): Balance<BKT>

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

65MutBorrowFieldGeneric[2](Well.shared_pool: Balance<Ty0>)

66MoveLoc[11](loc7: u64)

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

68Ret

}

public claim<Ty0>(Arg0: &mut Well<Ty0>, Arg1: &mut StakedBKT<Ty0>): Balance<Ty0> {

L2: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[5](StakedBKT.stake_weight: u64)

2ReadRef

3CastU128

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

5ImmBorrowFieldGeneric[3](Well.current_s: u128)

6ReadRef

7CopyLoc[1](Arg1: &mut StakedBKT<Ty0>)

8ImmBorrowFieldGeneric[6](StakedBKT.start_s: u128)

9ReadRef

10Sub

11Call constants::distribution_precision(): u128

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

13CastU64

14StLoc[2](loc0: u64)

15CopyLoc[2](loc0: u64)

16Call well_events::emit_claim<Ty0>(u64)

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

18ImmBorrowFieldGeneric[3](Well.current_s: u128)

19ReadRef

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

21MutBorrowFieldGeneric[6](StakedBKT.start_s: u128)

22WriteRef

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

24MutBorrowFieldGeneric[2](Well.shared_pool: Balance<Ty0>)

25MoveLoc[2](loc0: u64)

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

27Ret

}

public get_well_pool_balance<Ty0>(Arg0: &Well<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[2](Well.shared_pool: Balance<Ty0>)

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

3Ret

}

public get_well_staked_balance<Ty0>(Arg0: &Well<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[4](Well.staked: Balance<BKT>)

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

3Ret

}

public get_well_total_weight<Ty0>(Arg0: &Well<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[0](Well.total_weight: u64)

2ReadRef

3Ret

}

public get_well_reserve_balance<Ty0>(Arg0: &Well<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[1](Well.reserve: Balance<Ty0>)

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

3Ret

}

public get_token_stake_amount<Ty0>(Arg0: &StakedBKT<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[7](StakedBKT.stake_amount: u64)

2ReadRef

3Ret

}

public get_token_stake_weight<Ty0>(Arg0: &StakedBKT<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[5](StakedBKT.stake_weight: u64)

2ReadRef

3Ret

}

public get_token_lock_until<Ty0>(Arg0: &StakedBKT<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[8](StakedBKT.lock_until: u64)

2ReadRef

3Ret

}

public get_token_penalty_amount<Ty0>(Arg0: &StakedBKT<Ty0>, Arg1: u64): u64 {

L2: loc0: u64

L3: loc1: u64

B0:

0CopyLoc[1](Arg1: u64)

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

2ImmBorrowFieldGeneric[8](StakedBKT.lock_until: u64)

3ReadRef

4Ge

5BrFalse(11)

B1:

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

7Pop

8LdU64(0)

9StLoc[2](loc0: u64)

10Branch(31)

B2:

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

12ImmBorrowFieldGeneric[7](StakedBKT.stake_amount: u64)

13ReadRef

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

15ImmBorrowFieldGeneric[8](StakedBKT.lock_until: u64)

16ReadRef

17MoveLoc[1](Arg1: u64)

18Sub

19Call constants::max_lock_time(): u64

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

21StLoc[3](loc1: u64)

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

23ImmBorrowFieldGeneric[7](StakedBKT.stake_amount: u64)

24ReadRef

25MoveLoc[3](loc1: u64)

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

27ImmBorrowFieldGeneric[5](StakedBKT.stake_weight: u64)

28ReadRef

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

30StLoc[2](loc0: u64)

B3:

31MoveLoc[2](loc0: u64)

32Ret

}

public get_reward_amount<Ty0>(Arg0: &Well<Ty0>, Arg1: &StakedBKT<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[5](StakedBKT.stake_weight: u64)

2ReadRef

3CastU128

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

5ImmBorrowFieldGeneric[3](Well.current_s: u128)

6ReadRef

7MoveLoc[1](Arg1: &StakedBKT<Ty0>)

8ImmBorrowFieldGeneric[6](StakedBKT.start_s: u128)

9ReadRef

10Sub

11Call constants::distribution_precision(): u128

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

13CastU64

14Ret

}

public withdraw_reserve<Ty0>(Arg0: &BktAdminCap, Arg1: &mut Well<Ty0>): Balance<Ty0> {

L2: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[1](Well.reserve: Balance<Ty0>)

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

3StLoc[2](loc0: u64)

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

5MutBorrowFieldGeneric[1](Well.reserve: Balance<Ty0>)

6MoveLoc[2](loc0: u64)

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

8Ret

}

compute_weight(Arg0: u64, Arg1: u64): u64 {

L2: loc0: bool

L3: loc1: u64

B0:

0CopyLoc[1](Arg1: u64)

1Call constants::min_lock_time(): u64

2Ge

3BrFalse(9)

B1:

4CopyLoc[1](Arg1: u64)

5Call constants::max_lock_time(): u64

6Le

7StLoc[2](loc0: bool)

8Branch(11)

B2:

9LdFalse

10StLoc[2](loc0: bool)

B3:

11MoveLoc[2](loc0: bool)

12BrFalse(14)

B4:

13Branch(16)

B5:

14LdConst[2](u64: 2)

15Abort

B6:

16MoveLoc[0](Arg0: u64)

17MoveLoc[1](Arg1: u64)

18Call constants::max_lock_time(): u64

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

20StLoc[3](loc1: u64)

21CopyLoc[3](loc1: u64)

22LdU64(0)

23Gt

24BrFalse(26)

B7:

25Branch(28)

B8:

26LdConst[3](u64: 3)

27Abort

B9:

28MoveLoc[3](loc1: u64)

29Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 2

3 => u64: 3

]

}