gateway
Module0xbe89…7732
- Move path
- 0x3492…c267::gateway
- Functions
- 1010 public, 9 entry
- Structs
- 0
- Friend modules
- None
gateway
Bytecode673 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267.gateway {
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::config;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::errors;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::pool;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::position;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::utils;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
entry public create_pool<Ty0, Ty1>(Arg0: &Clock, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: u8, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: u8, Arg8: vector<u8>, Arg9: u32, Arg10: u64, Arg11: u128, Arg12: &mut TxContext) {
B0:
0Call errors::depricated(): u64
1Abort
}
entry public create_pool_v2<Ty0, Ty1, Ty2>(Arg0: &Clock, Arg1: &mut GlobalConfig, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: u8, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: u8, Arg9: vector<u8>, Arg10: u32, Arg11: u64, Arg12: u128, Arg13: Coin<Ty2>, Arg14: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &Clock)
1MoveLoc[1](Arg1: &mut GlobalConfig)
2MoveLoc[2](Arg2: vector<u8>)
3MoveLoc[3](Arg3: vector<u8>)
4MoveLoc[4](Arg4: vector<u8>)
5MoveLoc[5](Arg5: u8)
6MoveLoc[6](Arg6: vector<u8>)
7MoveLoc[7](Arg7: vector<u8>)
8MoveLoc[8](Arg8: u8)
9MoveLoc[9](Arg9: vector<u8>)
10MoveLoc[10](Arg10: u32)
11MoveLoc[11](Arg11: u64)
12MoveLoc[12](Arg12: u128)
13MoveLoc[13](Arg13: Coin<Ty2>)
14Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
15MoveLoc[14](Arg14: &mut TxContext)
16Call pool::create_pool<Ty0, Ty1, Ty2>(&Clock, &mut GlobalConfig, vector<u8>, vector<u8>, vector<u8>, u8, vector<u8>, vector<u8>, u8, vector<u8>, u32, u64, u128, Balance<Ty2>, &mut TxContext): ID
17Pop
18Ret
}
entry public provide_liquidity<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: Coin<Ty0>, Arg5: Coin<Ty1>, Arg6: u64, Arg7: u64, Arg8: u128, Arg9: &mut TxContext) {
L10: loc0: bool
L11: loc1: Balance<Ty0>
L12: loc2: Balance<Ty1>
L13: loc3: u64
L14: loc4: address
B0:
0CopyLoc[9](Arg9: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[14](loc4: address)
4MoveLoc[0](Arg0: &Clock)
5MoveLoc[1](Arg1: &GlobalConfig)
6MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
7MoveLoc[3](Arg3: &mut Position)
8MoveLoc[4](Arg4: Coin<Ty0>)
9Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
10MoveLoc[5](Arg5: Coin<Ty1>)
11Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
12MoveLoc[8](Arg8: u128)
13Call pool::add_liquidity<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, Balance<Ty0>, Balance<Ty1>, u128): u64 * u64 * Balance<Ty0> * Balance<Ty1>
14StLoc[12](loc2: Balance<Ty1>)
15StLoc[11](loc1: Balance<Ty0>)
16StLoc[13](loc3: u64)
17MoveLoc[6](Arg6: u64)
18Ge
19BrFalse(25)
B1:
20MoveLoc[13](loc3: u64)
21MoveLoc[7](Arg7: u64)
22Ge
23StLoc[10](loc0: bool)
24Branch(27)
B2:
25LdFalse
26StLoc[10](loc0: bool)
B3:
27MoveLoc[10](loc0: bool)
28BrFalse(30)
B4:
29Branch(34)
B5:
30MoveLoc[9](Arg9: &mut TxContext)
31Pop
32Call errors::slippage_exceeds(): u64
33Abort
B6:
34MoveLoc[11](loc1: Balance<Ty0>)
35CopyLoc[14](loc4: address)
36CopyLoc[9](Arg9: &mut TxContext)
37Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
38MoveLoc[12](loc2: Balance<Ty1>)
39MoveLoc[14](loc4: address)
40MoveLoc[9](Arg9: &mut TxContext)
41Call utils::transfer_balance<Ty1>(Balance<Ty1>, address, &mut TxContext)
42Ret
}
entry public provide_liquidity_with_fixed_amount<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: Coin<Ty0>, Arg5: Coin<Ty1>, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: bool, Arg10: &mut TxContext) {
L11: loc0: bool
L12: loc1: Balance<Ty0>
L13: loc2: Balance<Ty1>
L14: loc3: u64
L15: loc4: address
B0:
0CopyLoc[10](Arg10: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[15](loc4: address)
4MoveLoc[0](Arg0: &Clock)
5MoveLoc[1](Arg1: &GlobalConfig)
6MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
7MoveLoc[3](Arg3: &mut Position)
8MoveLoc[4](Arg4: Coin<Ty0>)
9Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
10MoveLoc[5](Arg5: Coin<Ty1>)
11Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
12MoveLoc[6](Arg6: u64)
13MoveLoc[9](Arg9: bool)
14Call pool::add_liquidity_with_fixed_amount<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, Balance<Ty0>, Balance<Ty1>, u64, bool): u64 * u64 * Balance<Ty0> * Balance<Ty1>
15StLoc[13](loc2: Balance<Ty1>)
16StLoc[12](loc1: Balance<Ty0>)
17StLoc[14](loc3: u64)
18MoveLoc[7](Arg7: u64)
19Le
20BrFalse(26)
B1:
21MoveLoc[14](loc3: u64)
22MoveLoc[8](Arg8: u64)
23Le
24StLoc[11](loc0: bool)
25Branch(28)
B2:
26LdFalse
27StLoc[11](loc0: bool)
B3:
28MoveLoc[11](loc0: bool)
29BrFalse(31)
B4:
30Branch(35)
B5:
31MoveLoc[10](Arg10: &mut TxContext)
32Pop
33Call errors::slippage_exceeds(): u64
34Abort
B6:
35MoveLoc[12](loc1: Balance<Ty0>)
36CopyLoc[15](loc4: address)
37CopyLoc[10](Arg10: &mut TxContext)
38Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
39MoveLoc[13](loc2: Balance<Ty1>)
40MoveLoc[15](loc4: address)
41MoveLoc[10](Arg10: &mut TxContext)
42Call utils::transfer_balance<Ty1>(Balance<Ty1>, address, &mut TxContext)
43Ret
}
entry public remove_liquidity<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: u128, Arg5: u64, Arg6: u64, Arg7: address, Arg8: &mut TxContext) {
L9: loc0: bool
L10: loc1: u64
L11: loc2: Balance<Ty0>
L12: loc3: Balance<Ty1>
B0:
0MoveLoc[1](Arg1: &GlobalConfig)
1MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
2MoveLoc[3](Arg3: &mut Position)
3MoveLoc[4](Arg4: u128)
4MoveLoc[0](Arg0: &Clock)
5Call pool::remove_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, &Clock): u64 * u64 * Balance<Ty0> * Balance<Ty1>
6StLoc[12](loc3: Balance<Ty1>)
7StLoc[11](loc2: Balance<Ty0>)
8StLoc[10](loc1: u64)
9MoveLoc[5](Arg5: u64)
10Ge
11BrFalse(17)
B1:
12MoveLoc[10](loc1: u64)
13MoveLoc[6](Arg6: u64)
14Ge
15StLoc[9](loc0: bool)
16Branch(19)
B2:
17LdFalse
18StLoc[9](loc0: bool)
B3:
19MoveLoc[9](loc0: bool)
20BrFalse(22)
B4:
21Branch(26)
B5:
22MoveLoc[8](Arg8: &mut TxContext)
23Pop
24Call errors::slippage_exceeds(): u64
25Abort
B6:
26MoveLoc[11](loc2: Balance<Ty0>)
27CopyLoc[7](Arg7: address)
28CopyLoc[8](Arg8: &mut TxContext)
29Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
30MoveLoc[12](loc3: Balance<Ty1>)
31MoveLoc[7](Arg7: address)
32MoveLoc[8](Arg8: &mut TxContext)
33Call utils::transfer_balance<Ty1>(Balance<Ty1>, address, &mut TxContext)
34Ret
}
entry public close_position<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Position, Arg4: address, Arg5: &mut TxContext) {
L6: loc0: Balance<Ty0>
L7: loc1: Balance<Ty1>
L8: loc2: Balance<Ty0>
L9: loc3: Balance<Ty1>
L10: loc4: Balance<Ty0>
L11: loc5: Balance<Ty1>
L12: loc6: u128
L13: loc7: Balance<Ty0>
L14: loc8: Balance<Ty1>
B0:
0ImmBorrowLoc[3](Arg3: Position)
1Call position::liquidity(&Position): u128
2StLoc[12](loc6: u128)
3CopyLoc[12](loc6: u128)
4LdU128(0)
5Gt
6BrFalse(22)
B1:
7CopyLoc[1](Arg1: &GlobalConfig)
8CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
9MutBorrowLoc[3](Arg3: Position)
10MoveLoc[12](loc6: u128)
11CopyLoc[0](Arg0: &Clock)
12Call pool::remove_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, &Clock): u64 * u64 * Balance<Ty0> * Balance<Ty1>
13StLoc[9](loc3: Balance<Ty1>)
14StLoc[8](loc2: Balance<Ty0>)
15Pop
16Pop
17MoveLoc[8](loc2: Balance<Ty0>)
18MoveLoc[9](loc3: Balance<Ty1>)
19StLoc[7](loc1: Balance<Ty1>)
20StLoc[6](loc0: Balance<Ty0>)
21Branch(26)
B2:
22Call balance::zero<Ty0>(): Balance<Ty0>
23Call balance::zero<Ty1>(): Balance<Ty1>
24StLoc[7](loc1: Balance<Ty1>)
25StLoc[6](loc0: Balance<Ty0>)
B3:
26MoveLoc[6](loc0: Balance<Ty0>)
27MoveLoc[7](loc1: Balance<Ty1>)
28StLoc[14](loc8: Balance<Ty1>)
29StLoc[13](loc7: Balance<Ty0>)
30CopyLoc[0](Arg0: &Clock)
31CopyLoc[1](Arg1: &GlobalConfig)
32CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
33MutBorrowLoc[3](Arg3: Position)
34Call pool::collect_fee<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position): u64 * u64 * Balance<Ty0> * Balance<Ty1>
35StLoc[11](loc5: Balance<Ty1>)
36StLoc[10](loc4: Balance<Ty0>)
37Pop
38Pop
39MutBorrowLoc[13](loc7: Balance<Ty0>)
40MoveLoc[10](loc4: Balance<Ty0>)
41Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
42Pop
43MutBorrowLoc[14](loc8: Balance<Ty1>)
44MoveLoc[11](loc5: Balance<Ty1>)
45Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
46Pop
47MoveLoc[0](Arg0: &Clock)
48MoveLoc[1](Arg1: &GlobalConfig)
49MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
50MoveLoc[3](Arg3: Position)
51Call pool::close_position_v2<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, Position)
52MoveLoc[13](loc7: Balance<Ty0>)
53CopyLoc[4](Arg4: address)
54CopyLoc[5](Arg5: &mut TxContext)
55Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
56MoveLoc[14](loc8: Balance<Ty1>)
57MoveLoc[4](Arg4: address)
58MoveLoc[5](Arg5: &mut TxContext)
59Call utils::transfer_balance<Ty1>(Balance<Ty1>, address, &mut TxContext)
60Ret
}
entry public swap_assets<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: bool, Arg6: bool, Arg7: u64, Arg8: u64, Arg9: u128, Arg10: &mut TxContext) {
L11: loc0: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &Clock)
1MoveLoc[1](Arg1: &GlobalConfig)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3MoveLoc[3](Arg3: Coin<Ty0>)
4Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
5MoveLoc[4](Arg4: Coin<Ty1>)
6Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
7MoveLoc[5](Arg5: bool)
8MoveLoc[6](Arg6: bool)
9MoveLoc[7](Arg7: u64)
10MoveLoc[8](Arg8: u64)
11MoveLoc[9](Arg9: u128)
12Call pool::swap<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, bool, bool, u64, u64, u128): Balance<Ty0> * Balance<Ty1>
13StLoc[11](loc0: Balance<Ty1>)
14CopyLoc[10](Arg10: &mut TxContext)
15FreezeRef
16Call tx_context::sender(&TxContext): address
17CopyLoc[10](Arg10: &mut TxContext)
18Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
19MoveLoc[11](loc0: Balance<Ty1>)
20CopyLoc[10](Arg10: &mut TxContext)
21FreezeRef
22Call tx_context::sender(&TxContext): address
23MoveLoc[10](Arg10: &mut TxContext)
24Call utils::transfer_balance<Ty1>(Balance<Ty1>, address, &mut TxContext)
25Ret
}
entry public flash_swap<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: bool, Arg6: bool, Arg7: u64, Arg8: u64, Arg9: u128, Arg10: &mut TxContext) {
L11: loc0: u64
L12: loc1: u64
L13: loc2: Balance<Ty0>
L14: loc3: Balance<Ty1>
L15: loc4: u64
L16: loc5: u64
L17: loc6: Balance<Ty0>
L18: loc7: Balance<Ty1>
L19: loc8: FlashSwapReceipt<Ty0, Ty1>
L20: loc9: Balance<Ty0>
L21: loc10: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &Clock)
1CopyLoc[1](Arg1: &GlobalConfig)
2CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3CopyLoc[5](Arg5: bool)
4CopyLoc[6](Arg6: bool)
5MoveLoc[7](Arg7: u64)
6MoveLoc[9](Arg9: u128)
7Call pool::flash_swap<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
8StLoc[19](loc8: FlashSwapReceipt<Ty0, Ty1>)
9StLoc[21](loc10: Balance<Ty1>)
10StLoc[20](loc9: Balance<Ty0>)
11ImmBorrowLoc[19](loc8: FlashSwapReceipt<Ty0, Ty1>)
12Call pool::swap_pay_amount<Ty0, Ty1>(&FlashSwapReceipt<Ty0, Ty1>): u64
13StLoc[12](loc1: u64)
14CopyLoc[5](Arg5: bool)
15BrFalse(20)
B1:
16ImmBorrowLoc[21](loc10: Balance<Ty1>)
17Call balance::value<Ty1>(&Balance<Ty1>): u64
18StLoc[11](loc0: u64)
19Branch(23)
B2:
20ImmBorrowLoc[20](loc9: Balance<Ty0>)
21Call balance::value<Ty0>(&Balance<Ty0>): u64
22StLoc[11](loc0: u64)
B3:
23MoveLoc[12](loc1: u64)
24MoveLoc[11](loc0: u64)
25StLoc[16](loc5: u64)
26StLoc[15](loc4: u64)
27MoveLoc[6](Arg6: bool)
28BrFalse(43)
B4:
29MoveLoc[16](loc5: u64)
30MoveLoc[8](Arg8: u64)
31Ge
32BrFalse(34)
B5:
33Branch(42)
B6:
34MoveLoc[1](Arg1: &GlobalConfig)
35Pop
36MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
37Pop
38MoveLoc[10](Arg10: &mut TxContext)
39Pop
40Call errors::slippage_exceeds(): u64
41Abort
B7:
42Branch(56)
B8:
43CopyLoc[15](loc4: u64)
44MoveLoc[8](Arg8: u64)
45Le
46BrFalse(48)
B9:
47Branch(56)
B10:
48MoveLoc[1](Arg1: &GlobalConfig)
49Pop
50MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
51Pop
52MoveLoc[10](Arg10: &mut TxContext)
53Pop
54Call errors::slippage_exceeds(): u64
55Abort
B11:
56MoveLoc[5](Arg5: bool)
57BrFalse(67)
B12:
58MutBorrowLoc[3](Arg3: Coin<Ty0>)
59MoveLoc[15](loc4: u64)
60CopyLoc[10](Arg10: &mut TxContext)
61Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
62Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
63Call balance::zero<Ty1>(): Balance<Ty1>
64StLoc[14](loc3: Balance<Ty1>)
65StLoc[13](loc2: Balance<Ty0>)
66Branch(75)
B13:
67Call balance::zero<Ty0>(): Balance<Ty0>
68MutBorrowLoc[4](Arg4: Coin<Ty1>)
69MoveLoc[15](loc4: u64)
70CopyLoc[10](Arg10: &mut TxContext)
71Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
72Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
73StLoc[14](loc3: Balance<Ty1>)
74StLoc[13](loc2: Balance<Ty0>)
B14:
75MoveLoc[13](loc2: Balance<Ty0>)
76MoveLoc[14](loc3: Balance<Ty1>)
77StLoc[18](loc7: Balance<Ty1>)
78StLoc[17](loc6: Balance<Ty0>)
79MutBorrowLoc[3](Arg3: Coin<Ty0>)
80MoveLoc[20](loc9: Balance<Ty0>)
81CopyLoc[10](Arg10: &mut TxContext)
82Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
83Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
84MutBorrowLoc[4](Arg4: Coin<Ty1>)
85MoveLoc[21](loc10: Balance<Ty1>)
86CopyLoc[10](Arg10: &mut TxContext)
87Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
88Call coin::join<Ty1>(&mut Coin<Ty1>, Coin<Ty1>)
89MoveLoc[1](Arg1: &GlobalConfig)
90MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
91MoveLoc[17](loc6: Balance<Ty0>)
92MoveLoc[18](loc7: Balance<Ty1>)
93MoveLoc[19](loc8: FlashSwapReceipt<Ty0, Ty1>)
94Call pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
95MoveLoc[3](Arg3: Coin<Ty0>)
96CopyLoc[10](Arg10: &mut TxContext)
97FreezeRef
98Call tx_context::sender(&TxContext): address
99Call utils::transfer_coin<Ty0>(Coin<Ty0>, address)
100MoveLoc[4](Arg4: Coin<Ty1>)
101MoveLoc[10](Arg10: &mut TxContext)
102FreezeRef
103Call tx_context::sender(&TxContext): address
104Call utils::transfer_coin<Ty1>(Coin<Ty1>, address)
105Ret
}
entry public collect_fee<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: &mut TxContext) {
L5: loc0: Balance<Ty0>
L6: loc1: Balance<Ty1>
L7: loc2: address
B0:
0CopyLoc[4](Arg4: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[7](loc2: address)
4MoveLoc[0](Arg0: &Clock)
5MoveLoc[1](Arg1: &GlobalConfig)
6MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
7MoveLoc[3](Arg3: &mut Position)
8Call pool::collect_fee<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position): u64 * u64 * Balance<Ty0> * Balance<Ty1>
9StLoc[6](loc1: Balance<Ty1>)
10StLoc[5](loc0: Balance<Ty0>)
11Pop
12Pop
13MoveLoc[5](loc0: Balance<Ty0>)
14CopyLoc[7](loc2: address)
15CopyLoc[4](Arg4: &mut TxContext)
16Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
17MoveLoc[6](loc1: Balance<Ty1>)
18MoveLoc[7](loc2: address)
19MoveLoc[4](Arg4: &mut TxContext)
20Call utils::transfer_balance<Ty1>(Balance<Ty1>, address, &mut TxContext)
21Ret
}
entry public collect_reward<Ty0, Ty1, Ty2>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: &mut TxContext) {
L5: loc0: Balance<Ty2>
L6: loc1: address
B0:
0CopyLoc[4](Arg4: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[6](loc1: address)
4MoveLoc[0](Arg0: &Clock)
5MoveLoc[1](Arg1: &GlobalConfig)
6MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
7MoveLoc[3](Arg3: &mut Position)
8Call pool::collect_reward<Ty0, Ty1, Ty2>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position): Balance<Ty2>
9StLoc[5](loc0: Balance<Ty2>)
10ImmBorrowLoc[5](loc0: Balance<Ty2>)
11Call balance::value<Ty2>(&Balance<Ty2>): u64
12LdU64(0)
13Gt
14BrFalse(16)
B1:
15Branch(20)
B2:
16MoveLoc[4](Arg4: &mut TxContext)
17Pop
18Call errors::can_not_claim_zero_reward(): u64
19Abort
B3:
20MoveLoc[5](loc0: Balance<Ty2>)
21MoveLoc[6](loc1: address)
22MoveLoc[4](Arg4: &mut TxContext)
23Call utils::transfer_balance<Ty2>(Balance<Ty2>, address, &mut TxContext)
24Ret
}
public route_swap<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: bool, Arg6: bool, Arg7: bool, Arg8: u64, Arg9: u64, Arg10: u128, Arg11: &mut TxContext): Coin<Ty0> * Coin<Ty1> {
L12: loc0: bool
L13: loc1: u64
L14: loc2: u64
L15: loc3: u64
L16: loc4: Balance<Ty0>
L17: loc5: Balance<Ty1>
L18: loc6: u64
L19: loc7: u64
L20: loc8: Balance<Ty0>
L21: loc9: Balance<Ty1>
L22: loc10: FlashSwapReceipt<Ty0, Ty1>
L23: loc11: Balance<Ty0>
L24: loc12: Balance<Ty1>
B0:
0CopyLoc[6](Arg6: bool)
1BrFalse(5)
B1:
2MoveLoc[7](Arg7: bool)
3StLoc[12](loc0: bool)
4Branch(7)
B2:
5LdFalse
6StLoc[12](loc0: bool)
B3:
7MoveLoc[12](loc0: bool)
8BrFalse(20)
B4:
9CopyLoc[5](Arg5: bool)
10BrFalse(15)
B5:
11ImmBorrowLoc[3](Arg3: Coin<Ty0>)
12Call coin::value<Ty0>(&Coin<Ty0>): u64
13StLoc[13](loc1: u64)
14Branch(18)
B6:
15ImmBorrowLoc[4](Arg4: Coin<Ty1>)
16Call coin::value<Ty1>(&Coin<Ty1>): u64
17StLoc[13](loc1: u64)
B7:
18MoveLoc[13](loc1: u64)
19StLoc[8](Arg8: u64)
B8:
20MoveLoc[0](Arg0: &Clock)
21CopyLoc[1](Arg1: &GlobalConfig)
22CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
23CopyLoc[5](Arg5: bool)
24CopyLoc[6](Arg6: bool)
25MoveLoc[8](Arg8: u64)
26MoveLoc[10](Arg10: u128)
27Call pool::flash_swap<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
28StLoc[22](loc10: FlashSwapReceipt<Ty0, Ty1>)
29StLoc[24](loc12: Balance<Ty1>)
30StLoc[23](loc11: Balance<Ty0>)
31ImmBorrowLoc[22](loc10: FlashSwapReceipt<Ty0, Ty1>)
32Call pool::swap_pay_amount<Ty0, Ty1>(&FlashSwapReceipt<Ty0, Ty1>): u64
33StLoc[15](loc3: u64)
34CopyLoc[5](Arg5: bool)
35BrFalse(40)
B9:
36ImmBorrowLoc[24](loc12: Balance<Ty1>)
37Call balance::value<Ty1>(&Balance<Ty1>): u64
38StLoc[14](loc2: u64)
39Branch(43)
B10:
40ImmBorrowLoc[23](loc11: Balance<Ty0>)
41Call balance::value<Ty0>(&Balance<Ty0>): u64
42StLoc[14](loc2: u64)
B11:
43MoveLoc[15](loc3: u64)
44MoveLoc[14](loc2: u64)
45StLoc[19](loc7: u64)
46StLoc[18](loc6: u64)
47MoveLoc[6](Arg6: bool)
48BrFalse(63)
B12:
49MoveLoc[19](loc7: u64)
50MoveLoc[9](Arg9: u64)
51Ge
52BrFalse(54)
B13:
53Branch(62)
B14:
54MoveLoc[1](Arg1: &GlobalConfig)
55Pop
56MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
57Pop
58MoveLoc[11](Arg11: &mut TxContext)
59Pop
60Call errors::slippage_exceeds(): u64
61Abort
B15:
62Branch(76)
B16:
63CopyLoc[18](loc6: u64)
64MoveLoc[9](Arg9: u64)
65Le
66BrFalse(68)
B17:
67Branch(76)
B18:
68MoveLoc[1](Arg1: &GlobalConfig)
69Pop
70MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
71Pop
72MoveLoc[11](Arg11: &mut TxContext)
73Pop
74Call errors::slippage_exceeds(): u64
75Abort
B19:
76MoveLoc[5](Arg5: bool)
77BrFalse(87)
B20:
78MutBorrowLoc[3](Arg3: Coin<Ty0>)
79MoveLoc[18](loc6: u64)
80CopyLoc[11](Arg11: &mut TxContext)
81Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
82Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
83Call balance::zero<Ty1>(): Balance<Ty1>
84StLoc[17](loc5: Balance<Ty1>)
85StLoc[16](loc4: Balance<Ty0>)
86Branch(95)
B21:
87Call balance::zero<Ty0>(): Balance<Ty0>
88MutBorrowLoc[4](Arg4: Coin<Ty1>)
89MoveLoc[18](loc6: u64)
90CopyLoc[11](Arg11: &mut TxContext)
91Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
92Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
93StLoc[17](loc5: Balance<Ty1>)
94StLoc[16](loc4: Balance<Ty0>)
B22:
95MoveLoc[16](loc4: Balance<Ty0>)
96MoveLoc[17](loc5: Balance<Ty1>)
97StLoc[21](loc9: Balance<Ty1>)
98StLoc[20](loc8: Balance<Ty0>)
99MutBorrowLoc[3](Arg3: Coin<Ty0>)
100MoveLoc[23](loc11: Balance<Ty0>)
101CopyLoc[11](Arg11: &mut TxContext)
102Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
103Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
104MutBorrowLoc[4](Arg4: Coin<Ty1>)
105MoveLoc[24](loc12: Balance<Ty1>)
106MoveLoc[11](Arg11: &mut TxContext)
107Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
108Call coin::join<Ty1>(&mut Coin<Ty1>, Coin<Ty1>)
109MoveLoc[1](Arg1: &GlobalConfig)
110MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
111MoveLoc[20](loc8: Balance<Ty0>)
112MoveLoc[21](loc9: Balance<Ty1>)
113MoveLoc[22](loc10: FlashSwapReceipt<Ty0, Ty1>)
114Call pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
115MoveLoc[3](Arg3: Coin<Ty0>)
116MoveLoc[4](Arg4: Coin<Ty1>)
117Ret
}
}