user_entry

Module0xafd7…d108

Move path: 0xcd86…fefa::user_entry
Functions: 88 public, 0 entry
Structs: 0
Friend modules: None

user_entry

Bytecode516 lines

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

// Move bytecode v7

module cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa.user_entry {

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000002::address;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::receipt;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::receipt_cancellation;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::reward_manager;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::swap_request;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::vault;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::vault_receipt_info;

struct WithdrawSwapRequested has copy, drop {

vault_id: address,

request_id: u64,

recipient: address,

target_asset_type: String,

slippage_bps: u64,

shares: u256

}

public deposit<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &mut RewardManager<Ty0>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u256, Arg5: Option<Receipt>, Arg6: &Clock, Arg7: &mut TxContext): u64 * Receipt * Coin<Ty0> {

L8: loc0: Receipt

L9: loc1: address

L10: loc2: Receipt

L11: loc3: Coin<Ty0>

B0:

0CopyLoc[3](Arg3: u64)

1LdU64(0)

2Gt

3BrFalse(5)

B1:

4Branch(15)

B2:

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

6Pop

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

8Pop

9MoveLoc[7](Arg7: &mut TxContext)

10Pop

11MoveLoc[6](Arg6: &Clock)

12Pop

13LdConst[4](u64: 4004)

14Abort

B3:

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

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

17CopyLoc[3](Arg3: u64)

18Ge

19BrFalse(21)

B4:

20Branch(31)

B5:

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

22Pop

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

24Pop

25MoveLoc[7](Arg7: &mut TxContext)

26Pop

27MoveLoc[6](Arg6: &Clock)

28Pop

29LdConst[1](u64: 4001)

30Abort

B6:

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

32FreezeRef

33Call vault::vault_id<Ty0>(&Vault<Ty0>): address

34CopyLoc[1](Arg1: &mut RewardManager<Ty0>)

35FreezeRef

36Call reward_manager::vault_id<Ty0>(&RewardManager<Ty0>): address

37Eq

38BrFalse(40)

B7:

39Branch(50)

B8:

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

41Pop

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

43Pop

44MoveLoc[7](Arg7: &mut TxContext)

45Pop

46MoveLoc[6](Arg6: &Clock)

47Pop

48LdConst[2](u64: 4002)

49Abort

B9:

50MutBorrowLoc[2](Arg2: Coin<Ty0>)

51MoveLoc[3](Arg3: u64)

52CopyLoc[7](Arg7: &mut TxContext)

53Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>

54StLoc[11](loc3: Coin<Ty0>)

55ImmBorrowLoc[5](Arg5: Option<Receipt>)

56Call option::is_some<Receipt>(&Option<Receipt>): bool

57Not

58BrFalse(65)

B10:

59CopyLoc[1](Arg1: &mut RewardManager<Ty0>)

60FreezeRef

61CopyLoc[7](Arg7: &mut TxContext)

62Call reward_manager::issue_receipt<Ty0>(&RewardManager<Ty0>, &mut TxContext): Receipt

63StLoc[8](loc0: Receipt)

64Branch(68)

B11:

65MutBorrowLoc[5](Arg5: Option<Receipt>)

66Call option::extract<Receipt>(&mut Option<Receipt>): Receipt

67StLoc[8](loc0: Receipt)

B12:

68MoveLoc[8](loc0: Receipt)

69StLoc[10](loc2: Receipt)

70MoveLoc[5](Arg5: Option<Receipt>)

71Call option::destroy_none<Receipt>(Option<Receipt>)

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

73FreezeRef

74ImmBorrowLoc[10](loc2: Receipt)

75Call vault::assert_vault_receipt_matched<Ty0>(&Vault<Ty0>, &Receipt)

76ImmBorrowLoc[10](loc2: Receipt)

77Call receipt::receipt_id(&Receipt): address

78StLoc[9](loc1: address)

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

80FreezeRef

81CopyLoc[9](loc1: address)

82Call vault::contains_vault_receipt_info<Ty0>(&Vault<Ty0>, address): bool

83Not

84BrFalse(93)

B13:

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

86CopyLoc[9](loc1: address)

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

88FreezeRef

89CopyLoc[7](Arg7: &mut TxContext)

90Call reward_manager::issue_vault_receipt_info<Ty0>(&RewardManager<Ty0>, &mut TxContext): VaultReceiptInfo

91Call vault::add_vault_receipt_info<Ty0>(&mut Vault<Ty0>, address, VaultReceiptInfo)

92Branch(95)

B14:

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

94Pop

B15:

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

96MoveLoc[11](loc3: Coin<Ty0>)

97MoveLoc[6](Arg6: &Clock)

98MoveLoc[4](Arg4: u256)

99MoveLoc[9](loc1: address)

100MoveLoc[7](Arg7: &mut TxContext)

101FreezeRef

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

103Call vault::request_deposit<Ty0>(&mut Vault<Ty0>, Coin<Ty0>, &Clock, u256, address, address): u64

104MoveLoc[10](loc2: Receipt)

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

106Ret

}

public deposit_with_auto_transfer<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &mut RewardManager<Ty0>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u256, Arg5: Option<Receipt>, Arg6: &Clock, Arg7: &mut TxContext): u64 {

L8: loc0: Coin<Ty0>

L9: loc1: u64

L10: loc2: Receipt

B0:

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

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

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

3MoveLoc[3](Arg3: u64)

4MoveLoc[4](Arg4: u256)

5MoveLoc[5](Arg5: Option<Receipt>)

6MoveLoc[6](Arg6: &Clock)

7CopyLoc[7](Arg7: &mut TxContext)

8Call deposit<Ty0>(&mut Vault<Ty0>, &mut RewardManager<Ty0>, Coin<Ty0>, u64, u256, Option<Receipt>, &Clock, &mut TxContext): u64 * Receipt * Coin<Ty0>

9StLoc[8](loc0: Coin<Ty0>)

10StLoc[10](loc2: Receipt)

11StLoc[9](loc1: u64)

12MoveLoc[10](loc2: Receipt)

13CopyLoc[7](Arg7: &mut TxContext)

14FreezeRef

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

16Call transfer::public_transfer<Receipt>(Receipt, address)

17MoveLoc[8](loc0: Coin<Ty0>)

18MoveLoc[7](Arg7: &mut TxContext)

19FreezeRef

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

21Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

22MoveLoc[9](loc1: u64)

23Ret

}

public cancel_deposit<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &mut Receipt, Arg2: u64, Arg3: &Clock, Arg4: &mut TxContext): Coin<Ty0> {

B0:

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

1FreezeRef

2CopyLoc[1](Arg1: &mut Receipt)

3FreezeRef

4Call vault::assert_vault_receipt_matched<Ty0>(&Vault<Ty0>, &Receipt)

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

6FreezeRef

7Call vault::assert_normal<Ty0>(&Vault<Ty0>)

8CopyLoc[1](Arg1: &mut Receipt)

9FreezeRef

10Call receipt_cancellation::assert_receipt_can_be_cancelled(&Receipt)

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

12MoveLoc[3](Arg3: &Clock)

13MoveLoc[2](Arg2: u64)

14MoveLoc[1](Arg1: &mut Receipt)

15FreezeRef

16Call receipt::receipt_id(&Receipt): address

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

18FreezeRef

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

20Call vault::cancel_deposit<Ty0>(&mut Vault<Ty0>, &Clock, u64, address, address): Coin<Ty0>

21Ret

}

public cancel_deposit_with_auto_transfer<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &mut Receipt, Arg2: u64, Arg3: &Clock, Arg4: &mut TxContext) {

B0:

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

1MoveLoc[1](Arg1: &mut Receipt)

2MoveLoc[2](Arg2: u64)

3MoveLoc[3](Arg3: &Clock)

4CopyLoc[4](Arg4: &mut TxContext)

5Call cancel_deposit<Ty0>(&mut Vault<Ty0>, &mut Receipt, u64, &Clock, &mut TxContext): Coin<Ty0>

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

7FreezeRef

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

9Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

10Ret

}

public withdraw<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: u256, Arg2: u64, Arg3: &mut Receipt, Arg4: &Clock, Arg5: &mut TxContext): u64 {

B0:

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

1FreezeRef

2CopyLoc[3](Arg3: &mut Receipt)

3FreezeRef

4Call vault::assert_vault_receipt_matched<Ty0>(&Vault<Ty0>, &Receipt)

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

6FreezeRef

7CopyLoc[3](Arg3: &mut Receipt)

8FreezeRef

9Call receipt::receipt_id(&Receipt): address

10CopyLoc[4](Arg4: &Clock)

11Call vault::check_locking_time_for_withdraw<Ty0>(&Vault<Ty0>, address, &Clock): bool

12BrFalse(14)

B1:

13Branch(22)

B2:

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

15Pop

16MoveLoc[3](Arg3: &mut Receipt)

17Pop

18MoveLoc[4](Arg4: &Clock)

19Pop

20LdConst[3](u64: 4003)

21Abort

B3:

22CopyLoc[1](Arg1: u256)

23LdU256(0)

24Gt

25BrFalse(27)

B4:

26Branch(35)

B5:

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

28Pop

29MoveLoc[3](Arg3: &mut Receipt)

30Pop

31MoveLoc[4](Arg4: &Clock)

32Pop

33LdConst[4](u64: 4004)

34Abort

B6:

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

36MoveLoc[4](Arg4: &Clock)

37MoveLoc[3](Arg3: &mut Receipt)

38FreezeRef

39Call receipt::receipt_id(&Receipt): address

40MoveLoc[1](Arg1: u256)

41MoveLoc[2](Arg2: u64)

42LdU256(0)

43Call address::from_u256(u256): address

44Call vault::request_withdraw<Ty0>(&mut Vault<Ty0>, &Clock, address, u256, u64, address): u64

45Ret

}

public withdraw_with_auto_transfer<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: u256, Arg2: u64, Arg3: &mut Receipt, Arg4: &Clock, Arg5: &mut TxContext): u64 {

B0:

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

1FreezeRef

2CopyLoc[3](Arg3: &mut Receipt)

3FreezeRef

4Call vault::assert_vault_receipt_matched<Ty0>(&Vault<Ty0>, &Receipt)

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

6FreezeRef

7CopyLoc[3](Arg3: &mut Receipt)

8FreezeRef

9Call receipt::receipt_id(&Receipt): address

10CopyLoc[4](Arg4: &Clock)

11Call vault::check_locking_time_for_withdraw<Ty0>(&Vault<Ty0>, address, &Clock): bool

12BrFalse(14)

B1:

13Branch(24)

B2:

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

15Pop

16MoveLoc[3](Arg3: &mut Receipt)

17Pop

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

19Pop

20MoveLoc[4](Arg4: &Clock)

21Pop

22LdConst[3](u64: 4003)

23Abort

B3:

24CopyLoc[1](Arg1: u256)

25LdU256(0)

26Gt

27BrFalse(29)

B4:

28Branch(39)

B5:

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

30Pop

31MoveLoc[3](Arg3: &mut Receipt)

32Pop

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

34Pop

35MoveLoc[4](Arg4: &Clock)

36Pop

37LdConst[4](u64: 4004)

38Abort

B6:

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

40MoveLoc[4](Arg4: &Clock)

41MoveLoc[3](Arg3: &mut Receipt)

42FreezeRef

43Call receipt::receipt_id(&Receipt): address

44MoveLoc[1](Arg1: u256)

45MoveLoc[2](Arg2: u64)

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

47FreezeRef

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

49Call vault::request_withdraw<Ty0>(&mut Vault<Ty0>, &Clock, address, u256, u64, address): u64

50Ret

}

public cancel_withdraw<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &mut Receipt, Arg2: u64, Arg3: &Clock, Arg4: &mut TxContext): u256 {

L5: loc0: u256

B0:

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

1FreezeRef

2CopyLoc[1](Arg1: &mut Receipt)

3FreezeRef

4Call vault::assert_vault_receipt_matched<Ty0>(&Vault<Ty0>, &Receipt)

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

6FreezeRef

7Call vault::assert_normal<Ty0>(&Vault<Ty0>)

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

9MoveLoc[3](Arg3: &Clock)

10CopyLoc[2](Arg2: u64)

11MoveLoc[1](Arg1: &mut Receipt)

12FreezeRef

13Call receipt::receipt_id(&Receipt): address

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

15FreezeRef

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

17Call vault::cancel_withdraw<Ty0>(&mut Vault<Ty0>, &Clock, u64, address, address): u256

18StLoc[5](loc0: u256)

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

20MoveLoc[2](Arg2: u64)

21Call swap_request::try_delete_withdraw_swap_request<Ty0>(&mut Vault<Ty0>, u64)

22MoveLoc[5](loc0: u256)

23Ret

}

public claim_claimable_principal<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &mut Receipt, Arg2: u64): Balance<Ty0> {

B0:

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

1FreezeRef

2CopyLoc[1](Arg1: &mut Receipt)

3FreezeRef

4Call vault::assert_vault_receipt_matched<Ty0>(&Vault<Ty0>, &Receipt)

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

6MoveLoc[1](Arg1: &mut Receipt)

7FreezeRef

8Call receipt::receipt_id(&Receipt): address

9MoveLoc[2](Arg2: u64)

10Call vault::claim_claimable_principal<Ty0>(&mut Vault<Ty0>, address, u64): Balance<Ty0>

11Ret

}

public withdraw_with_swap<Ty0, Ty1>(Arg0: &mut Vault<Ty0>, Arg1: u256, Arg2: u64, Arg3: &mut Receipt, Arg4: &Clock, Arg5: u64, Arg6: &mut TxContext): u64 {

L7: loc0: address

L8: loc1: u64

L9: loc2: WithdrawSwapRequest

L10: loc3: String

B0:

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

1FreezeRef

2CopyLoc[3](Arg3: &mut Receipt)

3FreezeRef

4Call vault::assert_vault_receipt_matched<Ty0>(&Vault<Ty0>, &Receipt)

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

6FreezeRef

7CopyLoc[3](Arg3: &mut Receipt)

8FreezeRef

9Call receipt::receipt_id(&Receipt): address

10CopyLoc[4](Arg4: &Clock)

11Call vault::check_locking_time_for_withdraw<Ty0>(&Vault<Ty0>, address, &Clock): bool

12BrFalse(14)

B1:

13Branch(24)

B2:

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

15Pop

16MoveLoc[3](Arg3: &mut Receipt)

17Pop

18MoveLoc[6](Arg6: &mut TxContext)

19Pop

20MoveLoc[4](Arg4: &Clock)

21Pop

22LdConst[3](u64: 4003)

23Abort

B3:

24CopyLoc[1](Arg1: u256)

25LdU256(0)

26Gt

27BrFalse(29)

B4:

28Branch(39)

B5:

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

30Pop

31MoveLoc[3](Arg3: &mut Receipt)

32Pop

33MoveLoc[6](Arg6: &mut TxContext)

34Pop

35MoveLoc[4](Arg4: &Clock)

36Pop

37LdConst[4](u64: 4004)

38Abort

B6:

39CopyLoc[5](Arg5: u64)

40LdConst[0](u64: 10000)

41Le

42BrFalse(44)

B7:

43Branch(54)

B8:

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

45Pop

46MoveLoc[3](Arg3: &mut Receipt)

47Pop

48MoveLoc[6](Arg6: &mut TxContext)

49Pop

50MoveLoc[4](Arg4: &Clock)

51Pop

52LdConst[4](u64: 4004)

53Abort

B9:

54MoveLoc[6](Arg6: &mut TxContext)

55FreezeRef

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

57StLoc[7](loc0: address)

58Call type_name::with_defining_ids<Ty1>(): TypeName

59Call type_name::into_string(TypeName): String

60StLoc[10](loc3: String)

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

62MoveLoc[4](Arg4: &Clock)

63MoveLoc[3](Arg3: &mut Receipt)

64FreezeRef

65Call receipt::receipt_id(&Receipt): address

66CopyLoc[1](Arg1: u256)

67MoveLoc[2](Arg2: u64)

68CopyLoc[7](loc0: address)

69Call vault::request_withdraw<Ty0>(&mut Vault<Ty0>, &Clock, address, u256, u64, address): u64

70StLoc[8](loc1: u64)

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

72FreezeRef

73Call vault::vault_id<Ty0>(&Vault<Ty0>): address

74CopyLoc[8](loc1: u64)

75CopyLoc[7](loc0: address)

76CopyLoc[10](loc3: String)

77CopyLoc[5](Arg5: u64)

78Call swap_request::new_withdraw_swap_request(address, u64, address, String, u64): WithdrawSwapRequest

79StLoc[9](loc2: WithdrawSwapRequest)

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

81Call swap_request::withdraw_swap_requests_mut<Ty0>(&mut Vault<Ty0>): &mut Table<u64, WithdrawSwapRequest>

82CopyLoc[8](loc1: u64)

83MoveLoc[9](loc2: WithdrawSwapRequest)

84Call table::add<u64, WithdrawSwapRequest>(&mut Table<u64, WithdrawSwapRequest>, u64, WithdrawSwapRequest)

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

86FreezeRef

87Call vault::vault_id<Ty0>(&Vault<Ty0>): address

88CopyLoc[8](loc1: u64)

89MoveLoc[7](loc0: address)

90MoveLoc[10](loc3: String)

91MoveLoc[5](Arg5: u64)

92MoveLoc[1](Arg1: u256)

93Pack[0](WithdrawSwapRequested)

94Call event::emit<WithdrawSwapRequested>(WithdrawSwapRequested)

95MoveLoc[8](loc1: u64)

96Ret

}

Constants [

0 => u64: 10000

1 => u64: 4001

2 => u64: 4002

3 => u64: 4003

4 => u64: 4004

]

}