operation

Move path: 0xcd86…fefa::operation
Functions: 1817 public, 0 entry
Structs: 5
Friend modules: None

operation

Bytecode1378 lines

The on-chain disassembly. Offsets are instruction numbers within each function.

// Move bytecode v7

module cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa.operation {

use d899cf7d2b5db716bd2cf55599fb0d5ee38a3061e7b6bb6eebf73fa5bc4c81ca::account;

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::address;

use 0000000000000000000000000000000000000000000000000000000000000002::bag;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::curator_position;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::deposit_request;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::navi_adaptor;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::receipt;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::receipt_cancellation;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::reward_manager;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::swap_request;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::vault;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::vault_oracle;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::vault_utils;

use cd86f77503a755c48fe6c87e1b8e9a137ec0c1bf37aac8878b6083262b27fefa::withdraw_request;

struct OperationStarted has copy, drop {

vault_id: address,

defi_asset_ids: vector<u8>,

defi_asset_types: vector<TypeName>,

principal_coin_type: TypeName,

principal_amount: u64,

coin_type_asset_type: TypeName,

coin_type_asset_amount: u64,

total_usd_value: u256

}

struct OperationEnded has copy, drop {

vault_id: address,

defi_asset_ids: vector<u8>,

defi_asset_types: vector<TypeName>,

principal_coin_type: TypeName,

principal_amount: u64,

coin_type_asset_type: TypeName,

coin_type_asset_amount: u64

}

struct OperationValueUpdateChecked has copy, drop {

vault_id: address,

total_usd_value_before: u256,

total_usd_value_after: u256,

loss: u256

}

struct WithdrawWithSwapBag {

vault_id: address,

request_id: u64,

target_asset_type: String,

target_asset_min_amount_out: u64,

slippage_bps: u64,

recipient: address

}

struct WithdrawWithSwapExecuted has copy, drop {

vault_id: address,

request_id: u64,

recipient: address,

target_asset_type: String,

target_asset_min_amount_out: u64,

slippage_bps: u64,

target_asset_amount: u64

}

struct TxBag {

vault_id: address,

defi_asset_ids: vector<u8>,

defi_asset_types: vector<TypeName>

}

struct TxBagForCheckValueUpdate {

vault_id: address,

defi_asset_ids: vector<u8>,

defi_asset_types: vector<TypeName>,

total_usd_value: u256,

total_shares: u256

}

public(friend) pre_vault_check<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &TxContext) {

B0:

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

1FreezeRef

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

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

4LdConst[1](u8: 1)

5Call vault::set_status<Ty0>(&mut Vault<Ty0>, u8)

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

7LdFalse

8MoveLoc[1](Arg1: &TxContext)

9Call vault::try_reset_tolerance<Ty0>(&mut Vault<Ty0>, bool, &TxContext)

10Ret

}

public start_op_with_bag_v2<Ty0, Ty1, Ty2: store + key>(Arg0: &mut Vault<Ty0>, Arg1: &Operation, Arg2: &OperatorCap, Arg3: &Clock, Arg4: vector<u8>, Arg5: vector<TypeName>, Arg6: u64, Arg7: u64, Arg8: &mut TxContext): Bag * TxBag * TxBagForCheckValueUpdate * Balance<Ty0> * Balance<Ty1> {

L9: loc0: Balance<Ty0>

L10: loc1: Balance<Ty1>

L11: loc2: Balance<Ty1>

L12: loc3: Ty2

L13: loc4: u8

L14: loc5: String

L15: loc6: Bag

L16: loc7: u64

L17: loc8: u64

L18: loc9: Balance<Ty0>

L19: loc10: u256

L20: loc11: u256

L21: loc12: TxBag

L22: loc13: TxBagForCheckValueUpdate

B0:

0CopyLoc[1](Arg1: &Operation)

1CopyLoc[2](Arg2: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[1](Arg1: &Operation)

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

5FreezeRef

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

7MoveLoc[2](Arg2: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

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

10CopyLoc[8](Arg8: &mut TxContext)

11FreezeRef

12Call pre_vault_check<Ty0>(&mut Vault<Ty0>, &TxContext)

13MoveLoc[8](Arg8: &mut TxContext)

14Call bag::new(&mut TxContext): Bag

15StLoc[15](loc6: Bag)

16ImmBorrowLoc[4](Arg4: vector<u8>)

17VecLen(33)

18StLoc[16](loc7: u64)

19CopyLoc[16](loc7: u64)

20ImmBorrowLoc[5](Arg5: vector<TypeName>)

21VecLen(34)

22Eq

23BrFalse(25)

B1:

24Branch(31)

B2:

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

26Pop

27MoveLoc[3](Arg3: &Clock)

28Pop

29LdConst[4](u64: 1002)

30Abort

B3:

31LdU64(0)

32StLoc[17](loc8: u64)

B4:

33CopyLoc[17](loc8: u64)

34CopyLoc[16](loc7: u64)

35Lt

36BrFalse(72)

B5:

37ImmBorrowLoc[4](Arg4: vector<u8>)

38CopyLoc[17](loc8: u64)

39VecImmBorrow(33)

40ReadRef

41StLoc[13](loc4: u8)

42ImmBorrowLoc[5](Arg5: vector<TypeName>)

43CopyLoc[17](loc8: u64)

44VecImmBorrow(34)

45ReadRef

46Call type_name::get<Ty2>(): TypeName

47Eq

48BrFalse(50)

B6:

49Branch(56)

B7:

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

51Pop

52MoveLoc[3](Arg3: &Clock)

53Pop

54LdConst[7](u64: 1005)

55Abort

B8:

56MoveLoc[13](loc4: u8)

57Call vault_utils::parse_key<Ty2>(u8): String

58StLoc[14](loc5: String)

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

60CopyLoc[14](loc5: String)

61Call vault::borrow_defi_asset<Ty0, Ty2>(&mut Vault<Ty0>, String): Ty2

62StLoc[12](loc3: Ty2)

63MutBorrowLoc[15](loc6: Bag)

64MoveLoc[14](loc5: String)

65MoveLoc[12](loc3: Ty2)

66Call bag::add<String, Ty2>(&mut Bag, String, Ty2)

67MoveLoc[17](loc8: u64)

68LdU64(1)

69Add

70StLoc[17](loc8: u64)

71Branch(33)

B9:

72CopyLoc[6](Arg6: u64)

73LdU64(0)

74Gt

75BrFalse(81)

B10:

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

77CopyLoc[6](Arg6: u64)

78Call vault::borrow_free_principal<Ty0>(&mut Vault<Ty0>, u64): Balance<Ty0>

79StLoc[9](loc0: Balance<Ty0>)

80Branch(83)

B11:

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

82StLoc[9](loc0: Balance<Ty0>)

B12:

83MoveLoc[9](loc0: Balance<Ty0>)

84StLoc[18](loc9: Balance<Ty0>)

85CopyLoc[7](Arg7: u64)

86LdU64(0)

87Gt

88BrFalse(94)

B13:

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

90CopyLoc[7](Arg7: u64)

91Call vault::borrow_coin_type_asset<Ty0, Ty1>(&mut Vault<Ty0>, u64): Balance<Ty1>

92StLoc[10](loc1: Balance<Ty1>)

93Branch(96)

B14:

94Call balance::zero<Ty1>(): Balance<Ty1>

95StLoc[10](loc1: Balance<Ty1>)

B15:

96MoveLoc[10](loc1: Balance<Ty1>)

97StLoc[11](loc2: Balance<Ty1>)

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

99FreezeRef

100MoveLoc[3](Arg3: &Clock)

101Call vault::get_total_usd_value<Ty0>(&Vault<Ty0>, &Clock): u256

102StLoc[20](loc11: u256)

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

104FreezeRef

105Call vault::total_shares<Ty0>(&Vault<Ty0>): u256

106StLoc[19](loc10: u256)

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

108FreezeRef

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

110CopyLoc[4](Arg4: vector<u8>)

111CopyLoc[5](Arg5: vector<TypeName>)

112Pack[5](TxBag)

113StLoc[21](loc12: TxBag)

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

115FreezeRef

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

117CopyLoc[4](Arg4: vector<u8>)

118CopyLoc[5](Arg5: vector<TypeName>)

119CopyLoc[20](loc11: u256)

120MoveLoc[19](loc10: u256)

121Pack[6](TxBagForCheckValueUpdate)

122StLoc[22](loc13: TxBagForCheckValueUpdate)

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

124FreezeRef

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

126MoveLoc[4](Arg4: vector<u8>)

127MoveLoc[5](Arg5: vector<TypeName>)

128Call type_name::get<Ty0>(): TypeName

129MoveLoc[6](Arg6: u64)

130Call type_name::get<Ty1>(): TypeName

131MoveLoc[7](Arg7: u64)

132MoveLoc[20](loc11: u256)

133Pack[0](OperationStarted)

134Call event::emit<OperationStarted>(OperationStarted)

135MoveLoc[15](loc6: Bag)

136MoveLoc[21](loc12: TxBag)

137MoveLoc[22](loc13: TxBagForCheckValueUpdate)

138MoveLoc[18](loc9: Balance<Ty0>)

139MoveLoc[11](loc2: Balance<Ty1>)

140Ret

}

public end_op_with_bag_v2<Ty0, Ty1, Ty2: store + key>(Arg0: &mut Vault<Ty0>, Arg1: &Operation, Arg2: &OperatorCap, Arg3: Bag, Arg4: TxBag, Arg5: Balance<Ty0>, Arg6: Balance<Ty1>) {

L7: loc0: Ty2

L8: loc1: u8

L9: loc2: vector<u8>

L10: loc3: TypeName

L11: loc4: String

L12: loc5: vector<TypeName>

L13: loc6: u64

L14: loc7: u64

L15: loc8: Receipt

L16: loc9: address

B0:

0CopyLoc[1](Arg1: &Operation)

1CopyLoc[2](Arg2: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[1](Arg1: &Operation)

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

5FreezeRef

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

7MoveLoc[2](Arg2: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

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

10FreezeRef

11Call vault::assert_during_operation<Ty0>(&Vault<Ty0>)

12MoveLoc[4](Arg4: TxBag)

13Unpack[5](TxBag)

14StLoc[12](loc5: vector<TypeName>)

15StLoc[9](loc2: vector<u8>)

16StLoc[16](loc9: address)

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

18FreezeRef

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

20MoveLoc[16](loc9: address)

21Eq

22BrFalse(24)

B1:

23Branch(28)

B2:

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

25Pop

26LdConst[6](u64: 1004)

27Abort

B3:

28ImmBorrowLoc[9](loc2: vector<u8>)

29VecLen(33)

30StLoc[14](loc7: u64)

31LdU64(0)

32StLoc[13](loc6: u64)

B4:

33CopyLoc[13](loc6: u64)

34CopyLoc[14](loc7: u64)

35Lt

36BrFalse(95)

B5:

37ImmBorrowLoc[9](loc2: vector<u8>)

38CopyLoc[13](loc6: u64)

39VecImmBorrow(33)

40ReadRef

41StLoc[8](loc1: u8)

42ImmBorrowLoc[12](loc5: vector<TypeName>)

43CopyLoc[13](loc6: u64)

44VecImmBorrow(34)

45ReadRef

46StLoc[10](loc3: TypeName)

47CopyLoc[10](loc3: TypeName)

48Call type_name::get<Ty2>(): TypeName

49Eq

50BrFalse(86)

B6:

51Branch(52)

B7:

52MoveLoc[8](loc1: u8)

53Call vault_utils::parse_key<Ty2>(u8): String

54StLoc[11](loc4: String)

55CopyLoc[10](loc3: TypeName)

56Call type_name::get<Receipt>(): TypeName

57Eq

58BrFalse(70)

B8:

59MutBorrowLoc[3](Arg3: Bag)

60CopyLoc[11](loc4: String)

61Call bag::remove<String, Receipt>(&mut Bag, String): Receipt

62StLoc[15](loc8: Receipt)

63ImmBorrowLoc[15](loc8: Receipt)

64Call receipt_cancellation::assert_receipt_can_not_be_cancelled(&Receipt)

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

66MoveLoc[11](loc4: String)

67MoveLoc[15](loc8: Receipt)

68Call vault::return_defi_asset<Ty0, Receipt>(&mut Vault<Ty0>, String, Receipt)

69Branch(90)

B9:

70MutBorrowLoc[3](Arg3: Bag)

71CopyLoc[11](loc4: String)

72Call bag::remove<String, Ty2>(&mut Bag, String): Ty2

73StLoc[7](loc0: Ty2)

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

75CopyLoc[11](loc4: String)

76MoveLoc[7](loc0: Ty2)

77Call vault::return_defi_asset<Ty0, Ty2>(&mut Vault<Ty0>, String, Ty2)

78MoveLoc[10](loc3: TypeName)

79Call type_name::get<AccountCap>(): TypeName

80Eq

81BrFalse(90)

B10:

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

83MoveLoc[11](loc4: String)

84Call navi_adaptor::reset_navi_market_sync<Ty0>(&mut Vault<Ty0>, String)

85Branch(90)

B11:

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

87Pop

88LdConst[7](u64: 1005)

89Abort

B12:

90MoveLoc[13](loc6: u64)

91LdU64(1)

92Add

93StLoc[13](loc6: u64)

94Branch(33)

B13:

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

96FreezeRef

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

98MoveLoc[9](loc2: vector<u8>)

99MoveLoc[12](loc5: vector<TypeName>)

100Call type_name::get<Ty0>(): TypeName

101ImmBorrowLoc[5](Arg5: Balance<Ty0>)

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

103Call type_name::get<Ty1>(): TypeName

104ImmBorrowLoc[6](Arg6: Balance<Ty1>)

105Call balance::value<Ty1>(&Balance<Ty1>): u64

106Pack[1](OperationEnded)

107Call event::emit<OperationEnded>(OperationEnded)

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

109MoveLoc[5](Arg5: Balance<Ty0>)

110Call vault::return_free_principal<Ty0>(&mut Vault<Ty0>, Balance<Ty0>)

111ImmBorrowLoc[6](Arg6: Balance<Ty1>)

112Call balance::value<Ty1>(&Balance<Ty1>): u64

113LdU64(0)

114Gt

115BrFalse(120)

B14:

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

117MoveLoc[6](Arg6: Balance<Ty1>)

118Call vault::return_coin_type_asset<Ty0, Ty1>(&mut Vault<Ty0>, Balance<Ty1>)

119Branch(122)

B15:

120MoveLoc[6](Arg6: Balance<Ty1>)

121Call balance::destroy_zero<Ty1>(Balance<Ty1>)

B16:

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

123Call vault::enable_op_value_update<Ty0>(&mut Vault<Ty0>)

124MoveLoc[3](Arg3: Bag)

125Call bag::destroy_empty(Bag)

126Ret

}

public end_op_value_update_with_bag_v2<Ty0, Ty1: store + key>(Arg0: &mut Vault<Ty0>, Arg1: &Operation, Arg2: &OperatorCap, Arg3: &Clock, Arg4: TxBagForCheckValueUpdate) {

L5: loc0: u8

L6: loc1: vector<u8>

L7: loc2: String

L8: loc3: vector<TypeName>

L9: loc4: u64

L10: loc5: u64

L11: loc6: u256

L12: loc7: u256

L13: loc8: u256

L14: loc9: u256

L15: loc10: u256

L16: loc11: address

B0:

0CopyLoc[1](Arg1: &Operation)

1CopyLoc[2](Arg2: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[1](Arg1: &Operation)

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

5FreezeRef

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

7MoveLoc[2](Arg2: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

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

10FreezeRef

11Call vault::assert_during_operation<Ty0>(&Vault<Ty0>)

12MoveLoc[4](Arg4: TxBagForCheckValueUpdate)

13Unpack[6](TxBagForCheckValueUpdate)

14StLoc[12](loc7: u256)

15StLoc[13](loc8: u256)

16StLoc[8](loc3: vector<TypeName>)

17StLoc[6](loc1: vector<u8>)

18StLoc[16](loc11: address)

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

20FreezeRef

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

22MoveLoc[16](loc11: address)

23Eq

24BrFalse(26)

B1:

25Branch(32)

B2:

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

27Pop

28MoveLoc[3](Arg3: &Clock)

29Pop

30LdConst[6](u64: 1004)

31Abort

B3:

32ImmBorrowLoc[6](loc1: vector<u8>)

33VecLen(33)

34StLoc[10](loc5: u64)

35LdU64(0)

36StLoc[9](loc4: u64)

B4:

37CopyLoc[9](loc4: u64)

38CopyLoc[10](loc5: u64)

39Lt

40BrFalse(80)

B5:

41ImmBorrowLoc[6](loc1: vector<u8>)

42CopyLoc[9](loc4: u64)

43VecImmBorrow(33)

44ReadRef

45StLoc[5](loc0: u8)

46ImmBorrowLoc[8](loc3: vector<TypeName>)

47CopyLoc[9](loc4: u64)

48VecImmBorrow(34)

49ReadRef

50Call type_name::get<Ty1>(): TypeName

51Eq

52BrFalse(69)

B6:

53Branch(54)

B7:

54MoveLoc[5](loc0: u8)

55Call vault_utils::parse_key<Ty1>(u8): String

56StLoc[7](loc2: String)

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

58FreezeRef

59MoveLoc[7](loc2: String)

60Call vault::contains_asset_type<Ty0>(&Vault<Ty0>, String): bool

61BrFalse(63)

B8:

62Branch(75)

B9:

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

64Pop

65MoveLoc[3](Arg3: &Clock)

66Pop

67LdConst[5](u64: 1003)

68Abort

B10:

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

70Pop

71MoveLoc[3](Arg3: &Clock)

72Pop

73LdConst[7](u64: 1005)

74Abort

B11:

75MoveLoc[9](loc4: u64)

76LdU64(1)

77Add

78StLoc[9](loc4: u64)

79Branch(37)

B12:

80MoveLoc[13](loc8: u256)

81StLoc[15](loc10: u256)

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

83FreezeRef

84Call vault::check_op_value_update_record<Ty0>(&Vault<Ty0>)

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

86FreezeRef

87MoveLoc[3](Arg3: &Clock)

88Call vault::get_total_usd_value<Ty0>(&Vault<Ty0>, &Clock): u256

89StLoc[14](loc9: u256)

90LdU256(0)

91StLoc[11](loc6: u256)

92CopyLoc[14](loc9: u256)

93CopyLoc[15](loc10: u256)

94Lt

95BrFalse(103)

B13:

96CopyLoc[15](loc10: u256)

97CopyLoc[14](loc9: u256)

98Sub

99StLoc[11](loc6: u256)

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

101CopyLoc[11](loc6: u256)

102Call vault::update_tolerance<Ty0>(&mut Vault<Ty0>, u256)

B14:

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

104FreezeRef

105Call vault::total_shares<Ty0>(&Vault<Ty0>): u256

106MoveLoc[12](loc7: u256)

107Eq

108BrFalse(110)

B15:

109Branch(114)

B16:

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

111Pop

112LdConst[3](u64: 1001)

113Abort

B17:

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

115FreezeRef

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

117MoveLoc[15](loc10: u256)

118MoveLoc[14](loc9: u256)

119MoveLoc[11](loc6: u256)

120Pack[2](OperationValueUpdateChecked)

121Call event::emit<OperationValueUpdateChecked>(OperationValueUpdateChecked)

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

123LdConst[0](u8: 0)

124Call vault::set_status<Ty0>(&mut Vault<Ty0>, u8)

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

126Call vault::clear_op_value_update_record<Ty0>(&mut Vault<Ty0>)

127Ret

}

public start_op_with_bag<Ty0, Ty1, Ty2>(Arg0: &mut Vault<Ty0>, Arg1: &Operation, Arg2: &OperatorCap, Arg3: &Clock, Arg4: vector<u8>, Arg5: vector<TypeName>, Arg6: u64, Arg7: u64, Arg8: &mut TxContext): Bag * TxBag * TxBagForCheckValueUpdate * Balance<Ty0> * Balance<Ty1> {

B0:

0LdU64(0)

1Abort

}

public end_op_with_bag<Ty0, Ty1, Ty2>(Arg0: &mut Vault<Ty0>, Arg1: &Operation, Arg2: &OperatorCap, Arg3: Bag, Arg4: TxBag, Arg5: Balance<Ty0>, Arg6: Balance<Ty1>) {

B0:

0LdU64(0)

1Abort

}

public end_op_value_update_with_bag<Ty0, Ty1>(Arg0: &mut Vault<Ty0>, Arg1: &Operation, Arg2: &OperatorCap, Arg3: &Clock, Arg4: TxBagForCheckValueUpdate) {

B0:

0LdU64(0)

1Abort

}

public execute_deposit<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: &mut RewardManager<Ty0>, Arg4: &Clock, Arg5: &OracleConfig, Arg6: u64, Arg7: u256) {

L8: loc0: &DepositRequest

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9CopyLoc[3](Arg3: &mut RewardManager<Ty0>)

10CopyLoc[2](Arg2: &mut Vault<Ty0>)

11CopyLoc[4](Arg4: &Clock)

12Call reward_manager::update_reward_buffers<Ty0>(&mut RewardManager<Ty0>, &mut Vault<Ty0>, &Clock)

13CopyLoc[2](Arg2: &mut Vault<Ty0>)

14FreezeRef

15CopyLoc[6](Arg6: u64)

16Call vault::deposit_request<Ty0>(&Vault<Ty0>, u64): &DepositRequest

17StLoc[8](loc0: &DepositRequest)

18MoveLoc[3](Arg3: &mut RewardManager<Ty0>)

19FreezeRef

20CopyLoc[2](Arg2: &mut Vault<Ty0>)

21MoveLoc[8](loc0: &DepositRequest)

22Call deposit_request::receipt_id(&DepositRequest): address

23Call reward_manager::update_receipt_reward<Ty0>(&RewardManager<Ty0>, &mut Vault<Ty0>, address)

24MoveLoc[2](Arg2: &mut Vault<Ty0>)

25MoveLoc[4](Arg4: &Clock)

26MoveLoc[5](Arg5: &OracleConfig)

27MoveLoc[6](Arg6: u64)

28MoveLoc[7](Arg7: u256)

29Call vault::execute_deposit<Ty0>(&mut Vault<Ty0>, &Clock, &OracleConfig, u64, u256)

30Ret

}

public batch_execute_deposit<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: &mut RewardManager<Ty0>, Arg4: &Clock, Arg5: &OracleConfig, Arg6: vector<u64>, Arg7: vector<u256>) {

L8: loc0: u64

L9: loc1: &DepositRequest

L10: loc2: u64

L11: loc3: u64

L12: loc4: u64

L13: loc5: u64

L14: loc6: vector<u64>

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9CopyLoc[3](Arg3: &mut RewardManager<Ty0>)

10CopyLoc[2](Arg2: &mut Vault<Ty0>)

11CopyLoc[4](Arg4: &Clock)

12Call reward_manager::update_reward_buffers<Ty0>(&mut RewardManager<Ty0>, &mut Vault<Ty0>, &Clock)

13CopyLoc[6](Arg6: vector<u64>)

14StLoc[14](loc6: vector<u64>)

15MutBorrowLoc[14](loc6: vector<u64>)

16Call vector::reverse<u64>(&mut vector<u64>)

17ImmBorrowLoc[14](loc6: vector<u64>)

18VecLen(56)

19StLoc[8](loc0: u64)

20LdU64(0)

21StLoc[10](loc2: u64)

22MoveLoc[8](loc0: u64)

23StLoc[13](loc5: u64)

B1:

24CopyLoc[10](loc2: u64)

25CopyLoc[13](loc5: u64)

26Lt

27BrFalse(63)

B2:

28CopyLoc[10](loc2: u64)

29Pop

30MutBorrowLoc[14](loc6: vector<u64>)

31VecPopBack(56)

32StLoc[12](loc4: u64)

33CopyLoc[2](Arg2: &mut Vault<Ty0>)

34FreezeRef

35CopyLoc[12](loc4: u64)

36Call vault::deposit_request<Ty0>(&Vault<Ty0>, u64): &DepositRequest

37StLoc[9](loc1: &DepositRequest)

38CopyLoc[3](Arg3: &mut RewardManager<Ty0>)

39FreezeRef

40CopyLoc[2](Arg2: &mut Vault<Ty0>)

41MoveLoc[9](loc1: &DepositRequest)

42Call deposit_request::receipt_id(&DepositRequest): address

43Call reward_manager::update_receipt_reward<Ty0>(&RewardManager<Ty0>, &mut Vault<Ty0>, address)

44ImmBorrowLoc[6](Arg6: vector<u64>)

45ImmBorrowLoc[12](loc4: u64)

46Call vector::index_of<u64>(&vector<u64>, &u64): bool * u64

47StLoc[11](loc3: u64)

48Pop

49CopyLoc[2](Arg2: &mut Vault<Ty0>)

50CopyLoc[4](Arg4: &Clock)

51CopyLoc[5](Arg5: &OracleConfig)

52MoveLoc[12](loc4: u64)

53ImmBorrowLoc[7](Arg7: vector<u256>)

54MoveLoc[11](loc3: u64)

55VecImmBorrow(11)

56ReadRef

57Call vault::execute_deposit<Ty0>(&mut Vault<Ty0>, &Clock, &OracleConfig, u64, u256)

58MoveLoc[10](loc2: u64)

59LdU64(1)

60Add

61StLoc[10](loc2: u64)

62Branch(24)

B3:

63MoveLoc[2](Arg2: &mut Vault<Ty0>)

64Pop

65MoveLoc[3](Arg3: &mut RewardManager<Ty0>)

66Pop

67MoveLoc[5](Arg5: &OracleConfig)

68Pop

69MoveLoc[4](Arg4: &Clock)

70Pop

71MoveLoc[14](loc6: vector<u64>)

72VecUnpack(56, 0)

73Ret

}

public cancel_user_deposit<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: u64, Arg4: address, Arg5: address, Arg6: &Clock) {

L7: loc0: address

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9CopyLoc[2](Arg2: &mut Vault<Ty0>)

10FreezeRef

11CopyLoc[4](Arg4: address)

12Call receipt_cancellation::assert_receipt_can_be_cancelled_from_vault<Ty0>(&Vault<Ty0>, address)

13CopyLoc[2](Arg2: &mut Vault<Ty0>)

14FreezeRef

15CopyLoc[3](Arg3: u64)

16Call vault::deposit_request<Ty0>(&Vault<Ty0>, u64): &DepositRequest

17Call deposit_request::recipient(&DepositRequest): address

18StLoc[7](loc0: address)

19MoveLoc[2](Arg2: &mut Vault<Ty0>)

20MoveLoc[6](Arg6: &Clock)

21MoveLoc[3](Arg3: u64)

22MoveLoc[4](Arg4: address)

23CopyLoc[7](loc0: address)

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

25MoveLoc[7](loc0: address)

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

27Ret

}

public execute_withdraw<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: &mut RewardManager<Ty0>, Arg4: &Clock, Arg5: &OracleConfig, Arg6: u64, Arg7: u64, Arg8: &mut TxContext) {

L9: loc0: address

L10: loc1: Balance<Ty0>

L11: loc2: &WithdrawRequest

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9CopyLoc[3](Arg3: &mut RewardManager<Ty0>)

10CopyLoc[2](Arg2: &mut Vault<Ty0>)

11CopyLoc[4](Arg4: &Clock)

12Call reward_manager::update_reward_buffers<Ty0>(&mut RewardManager<Ty0>, &mut Vault<Ty0>, &Clock)

13CopyLoc[2](Arg2: &mut Vault<Ty0>)

14FreezeRef

15CopyLoc[6](Arg6: u64)

16Call vault::withdraw_request<Ty0>(&Vault<Ty0>, u64): &WithdrawRequest

17StLoc[11](loc2: &WithdrawRequest)

18MoveLoc[3](Arg3: &mut RewardManager<Ty0>)

19FreezeRef

20CopyLoc[2](Arg2: &mut Vault<Ty0>)

21MoveLoc[11](loc2: &WithdrawRequest)

22Call withdraw_request::receipt_id(&WithdrawRequest): address

23Call reward_manager::update_receipt_reward<Ty0>(&RewardManager<Ty0>, &mut Vault<Ty0>, address)

24CopyLoc[2](Arg2: &mut Vault<Ty0>)

25MoveLoc[4](Arg4: &Clock)

26MoveLoc[5](Arg5: &OracleConfig)

27CopyLoc[6](Arg6: u64)

28MoveLoc[7](Arg7: u64)

29Call vault::execute_withdraw<Ty0>(&mut Vault<Ty0>, &Clock, &OracleConfig, u64, u64): Balance<Ty0> * address

30StLoc[9](loc0: address)

31StLoc[10](loc1: Balance<Ty0>)

32CopyLoc[2](Arg2: &mut Vault<Ty0>)

33MoveLoc[6](Arg6: u64)

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

35CopyLoc[9](loc0: address)

36LdU256(0)

37Call address::from_u256(u256): address

38Neq

39BrFalse(48)

B1:

40MoveLoc[2](Arg2: &mut Vault<Ty0>)

41Pop

42MoveLoc[10](loc1: Balance<Ty0>)

43MoveLoc[8](Arg8: &mut TxContext)

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

45MoveLoc[9](loc0: address)

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

47Branch(53)

B2:

48MoveLoc[8](Arg8: &mut TxContext)

49Pop

50MoveLoc[2](Arg2: &mut Vault<Ty0>)

51MoveLoc[10](loc1: Balance<Ty0>)

52Call vault::add_claimable_principal<Ty0>(&mut Vault<Ty0>, Balance<Ty0>)

B3:

53Ret

}

public batch_execute_withdraw<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: &mut RewardManager<Ty0>, Arg4: &Clock, Arg5: &OracleConfig, Arg6: vector<u64>, Arg7: vector<u64>, Arg8: &mut TxContext) {

L9: loc0: u64

L10: loc1: u64

L11: loc2: u64

L12: loc3: address

L13: loc4: u64

L14: loc5: u64

L15: loc6: vector<u64>

L16: loc7: Balance<Ty0>

L17: loc8: &WithdrawRequest

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9CopyLoc[3](Arg3: &mut RewardManager<Ty0>)

10CopyLoc[2](Arg2: &mut Vault<Ty0>)

11CopyLoc[4](Arg4: &Clock)

12Call reward_manager::update_reward_buffers<Ty0>(&mut RewardManager<Ty0>, &mut Vault<Ty0>, &Clock)

13CopyLoc[6](Arg6: vector<u64>)

14StLoc[15](loc6: vector<u64>)

15MutBorrowLoc[15](loc6: vector<u64>)

16Call vector::reverse<u64>(&mut vector<u64>)

17ImmBorrowLoc[15](loc6: vector<u64>)

18VecLen(56)

19StLoc[9](loc0: u64)

20LdU64(0)

21StLoc[10](loc1: u64)

22MoveLoc[9](loc0: u64)

23StLoc[14](loc5: u64)

B1:

24CopyLoc[10](loc1: u64)

25CopyLoc[14](loc5: u64)

26Lt

27BrFalse(82)

B2:

28CopyLoc[10](loc1: u64)

29Pop

30MutBorrowLoc[15](loc6: vector<u64>)

31VecPopBack(56)

32StLoc[13](loc4: u64)

33CopyLoc[2](Arg2: &mut Vault<Ty0>)

34FreezeRef

35CopyLoc[13](loc4: u64)

36Call vault::withdraw_request<Ty0>(&Vault<Ty0>, u64): &WithdrawRequest

37StLoc[17](loc8: &WithdrawRequest)

38CopyLoc[3](Arg3: &mut RewardManager<Ty0>)

39FreezeRef

40CopyLoc[2](Arg2: &mut Vault<Ty0>)

41MoveLoc[17](loc8: &WithdrawRequest)

42Call withdraw_request::receipt_id(&WithdrawRequest): address

43Call reward_manager::update_receipt_reward<Ty0>(&RewardManager<Ty0>, &mut Vault<Ty0>, address)

44ImmBorrowLoc[6](Arg6: vector<u64>)

45ImmBorrowLoc[13](loc4: u64)

46Call vector::index_of<u64>(&vector<u64>, &u64): bool * u64

47StLoc[11](loc2: u64)

48Pop

49CopyLoc[2](Arg2: &mut Vault<Ty0>)

50CopyLoc[4](Arg4: &Clock)

51CopyLoc[5](Arg5: &OracleConfig)

52CopyLoc[13](loc4: u64)

53ImmBorrowLoc[7](Arg7: vector<u64>)

54MoveLoc[11](loc2: u64)

55VecImmBorrow(56)

56ReadRef

57Call vault::execute_withdraw<Ty0>(&mut Vault<Ty0>, &Clock, &OracleConfig, u64, u64): Balance<Ty0> * address

58StLoc[12](loc3: address)

59StLoc[16](loc7: Balance<Ty0>)

60CopyLoc[2](Arg2: &mut Vault<Ty0>)

61MoveLoc[13](loc4: u64)

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

63CopyLoc[12](loc3: address)

64LdU256(0)

65Call address::from_u256(u256): address

66Neq

67BrFalse(74)

B3:

68MoveLoc[16](loc7: Balance<Ty0>)

69CopyLoc[8](Arg8: &mut TxContext)

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

71MoveLoc[12](loc3: address)

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

73Branch(77)

B4:

74CopyLoc[2](Arg2: &mut Vault<Ty0>)

75MoveLoc[16](loc7: Balance<Ty0>)

76Call vault::add_claimable_principal<Ty0>(&mut Vault<Ty0>, Balance<Ty0>)

B5:

77MoveLoc[10](loc1: u64)

78LdU64(1)

79Add

80StLoc[10](loc1: u64)

81Branch(24)

B6:

82MoveLoc[2](Arg2: &mut Vault<Ty0>)

83Pop

84MoveLoc[3](Arg3: &mut RewardManager<Ty0>)

85Pop

86MoveLoc[8](Arg8: &mut TxContext)

87Pop

88MoveLoc[5](Arg5: &OracleConfig)

89Pop

90MoveLoc[4](Arg4: &Clock)

91Pop

92MoveLoc[15](loc6: vector<u64>)

93VecUnpack(56, 0)

94Ret

}

public cancel_user_withdraw<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: u64, Arg4: address, Arg5: address, Arg6: &Clock): u256 {

L7: loc0: u256

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9CopyLoc[2](Arg2: &mut Vault<Ty0>)

10MoveLoc[6](Arg6: &Clock)

11CopyLoc[3](Arg3: u64)

12MoveLoc[4](Arg4: address)

13MoveLoc[5](Arg5: address)

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

15StLoc[7](loc0: u256)

16MoveLoc[2](Arg2: &mut Vault<Ty0>)

17MoveLoc[3](Arg3: u64)

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

19MoveLoc[7](loc0: u256)

20Ret

}

public add_dynamic_field_withdraw_requests<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: &mut TxContext) {

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9MoveLoc[2](Arg2: &mut Vault<Ty0>)

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

11Call swap_request::add_dynamic_field_withdraw_requests<Ty0>(&mut Vault<Ty0>, &mut TxContext)

12Ret

}

public execute_withdraw_with_swap<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: &mut RewardManager<Ty0>, Arg4: &Clock, Arg5: &OracleConfig, Arg6: u64, Arg7: u64): Balance<Ty0> * WithdrawWithSwapBag {

L8: loc0: u256

L9: loc1: u256

L10: loc2: u256

L11: loc3: String

L12: loc4: address

L13: loc5: u64

L14: loc6: String

L15: loc7: u256

L16: loc8: Balance<Ty0>

L17: loc9: &WithdrawRequest

L18: loc10: WithdrawSwapRequest

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9CopyLoc[3](Arg3: &mut RewardManager<Ty0>)

10CopyLoc[2](Arg2: &mut Vault<Ty0>)

11CopyLoc[4](Arg4: &Clock)

12Call reward_manager::update_reward_buffers<Ty0>(&mut RewardManager<Ty0>, &mut Vault<Ty0>, &Clock)

13CopyLoc[2](Arg2: &mut Vault<Ty0>)

14FreezeRef

15CopyLoc[6](Arg6: u64)

16Call vault::withdraw_request<Ty0>(&Vault<Ty0>, u64): &WithdrawRequest

17StLoc[17](loc9: &WithdrawRequest)

18MoveLoc[3](Arg3: &mut RewardManager<Ty0>)

19FreezeRef

20CopyLoc[2](Arg2: &mut Vault<Ty0>)

21MoveLoc[17](loc9: &WithdrawRequest)

22Call withdraw_request::receipt_id(&WithdrawRequest): address

23Call reward_manager::update_receipt_reward<Ty0>(&RewardManager<Ty0>, &mut Vault<Ty0>, address)

24CopyLoc[2](Arg2: &mut Vault<Ty0>)

25FreezeRef

26Call swap_request::withdraw_swap_requests<Ty0>(&Vault<Ty0>): &Table<u64, WithdrawSwapRequest>

27CopyLoc[6](Arg6: u64)

28Call table::contains<u64, WithdrawSwapRequest>(&Table<u64, WithdrawSwapRequest>, u64): bool

29BrFalse(31)

B1:

30Branch(39)

B2:

31MoveLoc[2](Arg2: &mut Vault<Ty0>)

32Pop

33MoveLoc[5](Arg5: &OracleConfig)

34Pop

35MoveLoc[4](Arg4: &Clock)

36Pop

37LdConst[9](u64: 1007)

38Abort

B3:

39CopyLoc[2](Arg2: &mut Vault<Ty0>)

40CopyLoc[6](Arg6: u64)

41Call swap_request::delete_withdraw_swap_request<Ty0>(&mut Vault<Ty0>, u64): WithdrawSwapRequest

42StLoc[18](loc10: WithdrawSwapRequest)

43ImmBorrowLoc[18](loc10: WithdrawSwapRequest)

44Call swap_request::target_asset_type(&WithdrawSwapRequest): String

45StLoc[14](loc6: String)

46ImmBorrowLoc[18](loc10: WithdrawSwapRequest)

47Call swap_request::slippage_bps(&WithdrawSwapRequest): u64

48StLoc[13](loc5: u64)

49CopyLoc[2](Arg2: &mut Vault<Ty0>)

50CopyLoc[4](Arg4: &Clock)

51CopyLoc[5](Arg5: &OracleConfig)

52CopyLoc[6](Arg6: u64)

53MoveLoc[7](Arg7: u64)

54Call vault::execute_withdraw<Ty0>(&mut Vault<Ty0>, &Clock, &OracleConfig, u64, u64): Balance<Ty0> * address

55StLoc[12](loc4: address)

56StLoc[16](loc8: Balance<Ty0>)

57ImmBorrowLoc[16](loc8: Balance<Ty0>)

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

59CastU256

60StLoc[9](loc1: u256)

61Call type_name::with_defining_ids<Ty0>(): TypeName

62Call type_name::into_string(TypeName): String

63StLoc[11](loc3: String)

64CopyLoc[5](Arg5: &OracleConfig)

65CopyLoc[4](Arg4: &Clock)

66MoveLoc[11](loc3: String)

67Call vault_oracle::get_normalized_asset_price(&OracleConfig, &Clock, String): u256

68StLoc[10](loc2: u256)

69MoveLoc[5](Arg5: &OracleConfig)

70MoveLoc[4](Arg4: &Clock)

71CopyLoc[14](loc6: String)

72Call vault_oracle::get_normalized_asset_price(&OracleConfig, &Clock, String): u256

73StLoc[15](loc7: u256)

74MoveLoc[9](loc1: u256)

75MoveLoc[10](loc2: u256)

76Call vault_utils::mul_with_oracle_price(u256, u256): u256

77MoveLoc[15](loc7: u256)

78Call vault_utils::div_with_oracle_price(u256, u256): u256

79LdConst[2](u64: 10000)

80CopyLoc[13](loc5: u64)

81Sub

82CastU256

83Mul

84LdConst[2](u64: 10000)

85CastU256

86Div

87StLoc[8](loc0: u256)

88MoveLoc[16](loc8: Balance<Ty0>)

89MoveLoc[2](Arg2: &mut Vault<Ty0>)

90FreezeRef

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

92MoveLoc[6](Arg6: u64)

93MoveLoc[14](loc6: String)

94MoveLoc[8](loc0: u256)

95CastU64

96MoveLoc[13](loc5: u64)

97MoveLoc[12](loc4: address)

98Pack[3](WithdrawWithSwapBag)

99Ret

}

public finish_execute_withdraw_with_swap<Ty0, Ty1>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: WithdrawWithSwapBag, Arg4: Coin<Ty1>) {

L5: loc0: address

L6: loc1: u64

L7: loc2: u64

L8: loc3: u64

L9: loc4: u64

L10: loc5: String

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9MoveLoc[3](Arg3: WithdrawWithSwapBag)

10Unpack[3](WithdrawWithSwapBag)

11StLoc[5](loc0: address)

12StLoc[7](loc2: u64)

13StLoc[9](loc4: u64)

14StLoc[10](loc5: String)

15StLoc[6](loc1: u64)

16CopyLoc[2](Arg2: &mut Vault<Ty0>)

17FreezeRef

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

19Eq

20BrFalse(22)

B1:

21Branch(26)

B2:

22MoveLoc[2](Arg2: &mut Vault<Ty0>)

23Pop

24LdConst[6](u64: 1004)

25Abort

B3:

26CopyLoc[10](loc5: String)

27Call type_name::get<Ty1>(): TypeName

28Call type_name::into_string(TypeName): String

29Eq

30BrFalse(32)

B4:

31Branch(36)

B5:

32MoveLoc[2](Arg2: &mut Vault<Ty0>)

33Pop

34LdConst[11](u64: 1009)

35Abort

B6:

36CopyLoc[2](Arg2: &mut Vault<Ty0>)

37CopyLoc[6](loc1: u64)

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

39ImmBorrowLoc[4](Arg4: Coin<Ty1>)

40Call coin::value<Ty1>(&Coin<Ty1>): u64

41StLoc[8](loc3: u64)

42CopyLoc[8](loc3: u64)

43CopyLoc[9](loc4: u64)

44Ge

45BrFalse(47)

B7:

46Branch(51)

B8:

47MoveLoc[2](Arg2: &mut Vault<Ty0>)

48Pop

49LdConst[10](u64: 1008)

50Abort

B9:

51MoveLoc[2](Arg2: &mut Vault<Ty0>)

52FreezeRef

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

54MoveLoc[6](loc1: u64)

55CopyLoc[5](loc0: address)

56MoveLoc[10](loc5: String)

57MoveLoc[9](loc4: u64)

58MoveLoc[7](loc2: u64)

59MoveLoc[8](loc3: u64)

60Pack[4](WithdrawWithSwapExecuted)

61Call event::emit<WithdrawWithSwapExecuted>(WithdrawWithSwapExecuted)

62MoveLoc[4](Arg4: Coin<Ty1>)

63MoveLoc[5](loc0: address)

64Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)

65Ret

}

public deposit_by_operator<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: &Clock, Arg4: &OracleConfig, Arg5: Coin<Ty0>) {

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9MoveLoc[2](Arg2: &mut Vault<Ty0>)

10MoveLoc[3](Arg3: &Clock)

11MoveLoc[4](Arg4: &OracleConfig)

12MoveLoc[5](Arg5: Coin<Ty0>)

13Call vault::deposit_by_operator<Ty0>(&mut Vault<Ty0>, &Clock, &OracleConfig, Coin<Ty0>)

14Ret

}

public add_new_coin_type_asset<Ty0, Ty1>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>) {

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9MoveLoc[2](Arg2: &mut Vault<Ty0>)

10Call vault::add_new_coin_type_asset<Ty0, Ty1>(&mut Vault<Ty0>)

11Ret

}

public remove_coin_type_asset<Ty0, Ty1>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>) {

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9MoveLoc[2](Arg2: &mut Vault<Ty0>)

10Call vault::remove_coin_type_asset<Ty0, Ty1>(&mut Vault<Ty0>)

11Ret

}

public add_new_defi_asset<Ty0, Ty1: store + key>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: u8, Arg4: Ty1) {

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

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

10Call type_name::with_defining_ids<Receipt>(): TypeName

11Neq

12BrFalse(14)

B1:

13Branch(18)

B2:

14MoveLoc[2](Arg2: &mut Vault<Ty0>)

15Pop

16LdConst[7](u64: 1005)

17Abort

B3:

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

19Call type_name::with_defining_ids<CuratorPosition>(): TypeName

20Neq

21BrFalse(23)

B4:

22Branch(27)

B5:

23MoveLoc[2](Arg2: &mut Vault<Ty0>)

24Pop

25LdConst[7](u64: 1005)

26Abort

B6:

27MoveLoc[2](Arg2: &mut Vault<Ty0>)

28MoveLoc[3](Arg3: u8)

29MoveLoc[4](Arg4: Ty1)

30Call vault::add_new_defi_asset<Ty0, Ty1>(&mut Vault<Ty0>, u8, Ty1)

31Ret

}

public add_curator_position_as_defi_asset<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &CuratorConfig, Arg3: &mut Vault<Ty0>, Arg4: CuratorPosition) {

L5: loc0: address

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[3](Arg3: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9ImmBorrowLoc[4](Arg4: CuratorPosition)

10Call curator_position::position_id(&CuratorPosition): address

11StLoc[5](loc0: address)

12MoveLoc[2](Arg2: &CuratorConfig)

13MoveLoc[5](loc0: address)

14Call curator_position::curator_position_vault_id(&CuratorConfig, address): address

15CopyLoc[3](Arg3: &mut Vault<Ty0>)

16FreezeRef

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

18Eq

19BrFalse(21)

B1:

20Branch(25)

B2:

21MoveLoc[3](Arg3: &mut Vault<Ty0>)

22Pop

23LdConst[8](u64: 1006)

24Abort

B3:

25MoveLoc[3](Arg3: &mut Vault<Ty0>)

26LdU8(0)

27MoveLoc[4](Arg4: CuratorPosition)

28Call vault::add_new_defi_asset<Ty0, CuratorPosition>(&mut Vault<Ty0>, u8, CuratorPosition)

29Ret

}

public add_receipt_as_defi_asset<Ty0>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: u8, Arg4: Receipt) {

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9ImmBorrowLoc[4](Arg4: Receipt)

10Call receipt_cancellation::assert_receipt_can_not_be_cancelled(&Receipt)

11MoveLoc[2](Arg2: &mut Vault<Ty0>)

12MoveLoc[3](Arg3: u8)

13MoveLoc[4](Arg4: Receipt)

14Call vault::add_new_defi_asset<Ty0, Receipt>(&mut Vault<Ty0>, u8, Receipt)

15Ret

}

public remove_defi_asset_support<Ty0, Ty1: store + key>(Arg0: &Operation, Arg1: &OperatorCap, Arg2: &mut Vault<Ty0>, Arg3: u8): Ty1 {

B0:

0CopyLoc[0](Arg0: &Operation)

1CopyLoc[1](Arg1: &OperatorCap)

2Call vault::assert_operator_not_freezed(&Operation, &OperatorCap)

3MoveLoc[0](Arg0: &Operation)

4CopyLoc[2](Arg2: &mut Vault<Ty0>)

5FreezeRef

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

7MoveLoc[1](Arg1: &OperatorCap)

8Call vault::assert_single_vault_operator_paired(&Operation, address, &OperatorCap)

9MoveLoc[2](Arg2: &mut Vault<Ty0>)

10MoveLoc[3](Arg3: u8)

11Call vault::remove_defi_asset_support<Ty0, Ty1>(&mut Vault<Ty0>, u8): Ty1

12Ret

}

Constants [

0 => u8: 0

1 => u8: 1

2 => u64: 10000

3 => u64: 1001

4 => u64: 1002

5 => u64: 1003

6 => u64: 1004

7 => u64: 1005

8 => u64: 1006

9 => u64: 1007

10 => u64: 1008

11 => u64: 1009

]

}