pool_script_v2
Module0xb2db…ae2d
- Move path
- 0x996c…12c3::pool_script_v2
- Functions
- 2724 public, 23 entry
- Structs
- 0
- Friend modules
- None
pool_script_v2
Bytecode1102 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module 996c4d9480708fb8b92aa7acf819fb0497b5ec8e65ba06601cae2fb6db3312c3.pool_script_v2 {
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::config;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::factory;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::partner;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::position;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::rewarder;
use 996c4d9480708fb8b92aa7acf819fb0497b5ec8e65ba06601cae2fb6db3312c3::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
entry public create_pool<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pools, Arg2: u32, Arg3: u128, Arg4: String, Arg5: &Clock, Arg6: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut Pools)
1MoveLoc[0](Arg0: &GlobalConfig)
2MoveLoc[2](Arg2: u32)
3MoveLoc[3](Arg3: u128)
4MoveLoc[4](Arg4: String)
5MoveLoc[5](Arg5: &Clock)
6MoveLoc[6](Arg6: &mut TxContext)
7Call factory::create_pool<Ty0, Ty1>(&mut Pools, &GlobalConfig, u32, u128, String, &Clock, &mut TxContext)
8Ret
}
entry public create_pool_with_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pools, Arg2: u32, Arg3: u128, Arg4: String, Arg5: Coin<Ty0>, Arg6: Coin<Ty1>, Arg7: u32, Arg8: u32, Arg9: u64, Arg10: u64, Arg11: bool, Arg12: &Clock, Arg13: &mut TxContext) {
L14: loc0: Position
L15: loc1: Coin<Ty0>
L16: loc2: Coin<Ty1>
B0:
0MoveLoc[1](Arg1: &mut Pools)
1MoveLoc[0](Arg0: &GlobalConfig)
2MoveLoc[2](Arg2: u32)
3MoveLoc[3](Arg3: u128)
4MoveLoc[4](Arg4: String)
5MoveLoc[7](Arg7: u32)
6MoveLoc[8](Arg8: u32)
7MoveLoc[5](Arg5: Coin<Ty0>)
8MoveLoc[6](Arg6: Coin<Ty1>)
9MoveLoc[9](Arg9: u64)
10MoveLoc[10](Arg10: u64)
11MoveLoc[11](Arg11: bool)
12MoveLoc[12](Arg12: &Clock)
13CopyLoc[13](Arg13: &mut TxContext)
14Call factory::create_pool_with_liquidity<Ty0, Ty1>(&mut Pools, &GlobalConfig, u32, u128, String, u32, u32, Coin<Ty0>, Coin<Ty1>, u64, u64, bool, &Clock, &mut TxContext): Position * Coin<Ty0> * Coin<Ty1>
15StLoc[16](loc2: Coin<Ty1>)
16StLoc[15](loc1: Coin<Ty0>)
17StLoc[14](loc0: Position)
18MoveLoc[15](loc1: Coin<Ty0>)
19CopyLoc[13](Arg13: &mut TxContext)
20FreezeRef
21Call tx_context::sender(&TxContext): address
22Call utils::send_coin<Ty0>(Coin<Ty0>, address)
23MoveLoc[16](loc2: Coin<Ty1>)
24CopyLoc[13](Arg13: &mut TxContext)
25FreezeRef
26Call tx_context::sender(&TxContext): address
27Call utils::send_coin<Ty1>(Coin<Ty1>, address)
28MoveLoc[14](loc0: Position)
29MoveLoc[13](Arg13: &mut TxContext)
30FreezeRef
31Call tx_context::sender(&TxContext): address
32Call transfer::public_transfer<Position>(Position, address)
33Ret
}
entry public open_position<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u32, Arg3: u32, Arg4: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: u32)
3MoveLoc[3](Arg3: u32)
4CopyLoc[4](Arg4: &mut TxContext)
5Call pool::open_position<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, u32, u32, &mut TxContext): Position
6MoveLoc[4](Arg4: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Call transfer::public_transfer<Position>(Position, address)
10Ret
}
entry public open_position_with_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u32, Arg3: u32, Arg4: Coin<Ty0>, Arg5: Coin<Ty1>, Arg6: u64, Arg7: u64, Arg8: u128, Arg9: &Clock, Arg10: &mut TxContext) {
L11: loc0: Position
L12: loc1: AddLiquidityReceipt<Ty0, Ty1>
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: u32)
3MoveLoc[3](Arg3: u32)
4CopyLoc[10](Arg10: &mut TxContext)
5Call pool::open_position<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, u32, u32, &mut TxContext): Position
6StLoc[11](loc0: Position)
7CopyLoc[0](Arg0: &GlobalConfig)
8CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
9MutBorrowLoc[11](loc0: Position)
10MoveLoc[8](Arg8: u128)
11MoveLoc[9](Arg9: &Clock)
12Call pool::add_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, &Clock): AddLiquidityReceipt<Ty0, Ty1>
13StLoc[12](loc1: AddLiquidityReceipt<Ty0, Ty1>)
14MoveLoc[0](Arg0: &GlobalConfig)
15MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16MoveLoc[12](loc1: AddLiquidityReceipt<Ty0, Ty1>)
17MoveLoc[4](Arg4: Coin<Ty0>)
18MoveLoc[5](Arg5: Coin<Ty1>)
19MoveLoc[6](Arg6: u64)
20MoveLoc[7](Arg7: u64)
21CopyLoc[10](Arg10: &mut TxContext)
22Call repay_add_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, AddLiquidityReceipt<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, u64, u64, &mut TxContext)
23MoveLoc[11](loc0: Position)
24MoveLoc[10](Arg10: &mut TxContext)
25FreezeRef
26Call tx_context::sender(&TxContext): address
27Call transfer::public_transfer<Position>(Position, address)
28Ret
}
entry public open_position_with_liquidity_by_fix_coin<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u32, Arg3: u32, Arg4: Coin<Ty0>, Arg5: Coin<Ty1>, Arg6: u64, Arg7: u64, Arg8: bool, Arg9: &Clock, Arg10: &mut TxContext) {
L11: loc0: u64
L12: loc1: u64
L13: loc2: Position
L14: loc3: AddLiquidityReceipt<Ty0, Ty1>
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: u32)
3MoveLoc[3](Arg3: u32)
4CopyLoc[10](Arg10: &mut TxContext)
5Call pool::open_position<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, u32, u32, &mut TxContext): Position
6StLoc[13](loc2: Position)
7CopyLoc[8](Arg8: bool)
8BrFalse(12)
B1:
9CopyLoc[6](Arg6: u64)
10StLoc[11](loc0: u64)
11Branch(14)
B2:
12CopyLoc[7](Arg7: u64)
13StLoc[11](loc0: u64)
B3:
14MoveLoc[11](loc0: u64)
15StLoc[12](loc1: u64)
16CopyLoc[0](Arg0: &GlobalConfig)
17CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
18MutBorrowLoc[13](loc2: Position)
19MoveLoc[12](loc1: u64)
20MoveLoc[8](Arg8: bool)
21MoveLoc[9](Arg9: &Clock)
22Call pool::add_liquidity_fix_coin<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u64, bool, &Clock): AddLiquidityReceipt<Ty0, Ty1>
23StLoc[14](loc3: AddLiquidityReceipt<Ty0, Ty1>)
24MoveLoc[0](Arg0: &GlobalConfig)
25MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
26MoveLoc[14](loc3: AddLiquidityReceipt<Ty0, Ty1>)
27MoveLoc[4](Arg4: Coin<Ty0>)
28MoveLoc[5](Arg5: Coin<Ty1>)
29MoveLoc[6](Arg6: u64)
30MoveLoc[7](Arg7: u64)
31CopyLoc[10](Arg10: &mut TxContext)
32Call repay_add_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, AddLiquidityReceipt<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, u64, u64, &mut TxContext)
33MoveLoc[13](loc2: Position)
34MoveLoc[10](Arg10: &mut TxContext)
35FreezeRef
36Call tx_context::sender(&TxContext): address
37Call transfer::public_transfer<Position>(Position, address)
38Ret
}
entry public add_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: u64, Arg6: u64, Arg7: u128, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: AddLiquidityReceipt<Ty0, Ty1>
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut Position)
3MoveLoc[7](Arg7: u128)
4MoveLoc[8](Arg8: &Clock)
5Call pool::add_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, &Clock): AddLiquidityReceipt<Ty0, Ty1>
6StLoc[10](loc0: AddLiquidityReceipt<Ty0, Ty1>)
7MoveLoc[0](Arg0: &GlobalConfig)
8MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
9MoveLoc[10](loc0: AddLiquidityReceipt<Ty0, Ty1>)
10MoveLoc[3](Arg3: Coin<Ty0>)
11MoveLoc[4](Arg4: Coin<Ty1>)
12MoveLoc[5](Arg5: u64)
13MoveLoc[6](Arg6: u64)
14MoveLoc[9](Arg9: &mut TxContext)
15Call repay_add_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, AddLiquidityReceipt<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, u64, u64, &mut TxContext)
16Ret
}
entry public add_liquidity_by_fix_coin<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: u64, Arg6: u64, Arg7: bool, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: u64
L11: loc1: u64
L12: loc2: AddLiquidityReceipt<Ty0, Ty1>
B0:
0CopyLoc[7](Arg7: bool)
1BrFalse(5)
B1:
2CopyLoc[5](Arg5: u64)
3StLoc[10](loc0: u64)
4Branch(7)
B2:
5CopyLoc[6](Arg6: u64)
6StLoc[10](loc0: u64)
B3:
7MoveLoc[10](loc0: u64)
8StLoc[11](loc1: u64)
9CopyLoc[0](Arg0: &GlobalConfig)
10CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
11MoveLoc[2](Arg2: &mut Position)
12MoveLoc[11](loc1: u64)
13MoveLoc[7](Arg7: bool)
14MoveLoc[8](Arg8: &Clock)
15Call pool::add_liquidity_fix_coin<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u64, bool, &Clock): AddLiquidityReceipt<Ty0, Ty1>
16StLoc[12](loc2: AddLiquidityReceipt<Ty0, Ty1>)
17MoveLoc[0](Arg0: &GlobalConfig)
18MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
19MoveLoc[12](loc2: AddLiquidityReceipt<Ty0, Ty1>)
20MoveLoc[3](Arg3: Coin<Ty0>)
21MoveLoc[4](Arg4: Coin<Ty1>)
22MoveLoc[5](Arg5: u64)
23MoveLoc[6](Arg6: u64)
24MoveLoc[9](Arg9: &mut TxContext)
25Call repay_add_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, AddLiquidityReceipt<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, u64, u64, &mut TxContext)
26Ret
}
entry public remove_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: u128, Arg4: u64, Arg5: u64, Arg6: &Clock, Arg7: &mut TxContext) {
L8: loc0: Balance<Ty0>
L9: loc1: Balance<Ty1>
L10: loc2: Balance<Ty0>
L11: loc3: Balance<Ty1>
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2CopyLoc[2](Arg2: &mut Position)
3MoveLoc[3](Arg3: u128)
4MoveLoc[6](Arg6: &Clock)
5Call pool::remove_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, &Clock): Balance<Ty0> * Balance<Ty1>
6StLoc[9](loc1: Balance<Ty1>)
7StLoc[8](loc0: Balance<Ty0>)
8ImmBorrowLoc[8](loc0: Balance<Ty0>)
9Call balance::value<Ty0>(&Balance<Ty0>): u64
10MoveLoc[4](Arg4: u64)
11Ge
12BrFalse(14)
B1:
13Branch(24)
B2:
14MoveLoc[2](Arg2: &mut Position)
15Pop
16MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
17Pop
18MoveLoc[7](Arg7: &mut TxContext)
19Pop
20MoveLoc[0](Arg0: &GlobalConfig)
21Pop
22LdConst[1](u64: 1)
23Abort
B3:
24ImmBorrowLoc[9](loc1: Balance<Ty1>)
25Call balance::value<Ty1>(&Balance<Ty1>): u64
26MoveLoc[5](Arg5: u64)
27Ge
28BrFalse(30)
B4:
29Branch(40)
B5:
30MoveLoc[2](Arg2: &mut Position)
31Pop
32MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
33Pop
34MoveLoc[7](Arg7: &mut TxContext)
35Pop
36MoveLoc[0](Arg0: &GlobalConfig)
37Pop
38LdConst[1](u64: 1)
39Abort
B6:
40MoveLoc[0](Arg0: &GlobalConfig)
41MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
42MoveLoc[2](Arg2: &mut Position)
43FreezeRef
44LdFalse
45Call pool::collect_fee<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &Position, bool): Balance<Ty0> * Balance<Ty1>
46StLoc[11](loc3: Balance<Ty1>)
47StLoc[10](loc2: Balance<Ty0>)
48MutBorrowLoc[8](loc0: Balance<Ty0>)
49MoveLoc[10](loc2: Balance<Ty0>)
50Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
51Pop
52MutBorrowLoc[9](loc1: Balance<Ty1>)
53MoveLoc[11](loc3: Balance<Ty1>)
54Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
55Pop
56MoveLoc[8](loc0: Balance<Ty0>)
57CopyLoc[7](Arg7: &mut TxContext)
58Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
59CopyLoc[7](Arg7: &mut TxContext)
60FreezeRef
61Call tx_context::sender(&TxContext): address
62Call utils::send_coin<Ty0>(Coin<Ty0>, address)
63MoveLoc[9](loc1: Balance<Ty1>)
64CopyLoc[7](Arg7: &mut TxContext)
65Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
66MoveLoc[7](Arg7: &mut TxContext)
67FreezeRef
68Call tx_context::sender(&TxContext): address
69Call utils::send_coin<Ty1>(Coin<Ty1>, address)
70Ret
}
entry public close_position<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Position, Arg3: u64, Arg4: u64, Arg5: &Clock, Arg6: &mut TxContext) {
L7: loc0: u128
B0:
0MutBorrowLoc[2](Arg2: Position)
1FreezeRef
2Call position::liquidity(&Position): u128
3StLoc[7](loc0: u128)
4CopyLoc[7](loc0: u128)
5LdU128(0)
6Gt
7BrFalse(18)
B1:
8CopyLoc[0](Arg0: &GlobalConfig)
9CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10MutBorrowLoc[2](Arg2: Position)
11MoveLoc[7](loc0: u128)
12MoveLoc[3](Arg3: u64)
13MoveLoc[4](Arg4: u64)
14MoveLoc[5](Arg5: &Clock)
15MoveLoc[6](Arg6: &mut TxContext)
16Call remove_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, u64, u64, &Clock, &mut TxContext)
17Branch(22)
B2:
18MoveLoc[6](Arg6: &mut TxContext)
19Pop
20MoveLoc[5](Arg5: &Clock)
21Pop
B3:
22MoveLoc[0](Arg0: &GlobalConfig)
23MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24MoveLoc[2](Arg2: Position)
25Call pool::close_position<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Position)
26Ret
}
entry public collect_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: &mut TxContext) {
L6: loc0: Balance<Ty0>
L7: loc1: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut Position)
3FreezeRef
4LdTrue
5Call pool::collect_fee<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &Position, bool): Balance<Ty0> * Balance<Ty1>
6StLoc[7](loc1: Balance<Ty1>)
7StLoc[6](loc0: Balance<Ty0>)
8MutBorrowLoc[3](Arg3: Coin<Ty0>)
9MoveLoc[6](loc0: Balance<Ty0>)
10CopyLoc[5](Arg5: &mut TxContext)
11Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
12Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
13MutBorrowLoc[4](Arg4: Coin<Ty1>)
14MoveLoc[7](loc1: Balance<Ty1>)
15CopyLoc[5](Arg5: &mut TxContext)
16Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
17Call coin::join<Ty1>(&mut Coin<Ty1>, Coin<Ty1>)
18MoveLoc[3](Arg3: Coin<Ty0>)
19CopyLoc[5](Arg5: &mut TxContext)
20FreezeRef
21Call tx_context::sender(&TxContext): address
22Call utils::send_coin<Ty0>(Coin<Ty0>, address)
23MoveLoc[4](Arg4: Coin<Ty1>)
24MoveLoc[5](Arg5: &mut TxContext)
25FreezeRef
26Call tx_context::sender(&TxContext): address
27Call utils::send_coin<Ty1>(Coin<Ty1>, address)
28Ret
}
public close_position_with_return<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Position, Arg3: bool, Arg4: &Clock, Arg5: &mut TxContext): Coin<Ty0> * Coin<Ty1> {
L6: loc0: u128
L7: loc1: Balance<Ty0>
L8: loc2: Balance<Ty1>
L9: loc3: Balance<Ty0>
L10: loc4: Balance<Ty1>
B0:
0ImmBorrowLoc[2](Arg2: Position)
1Call position::liquidity(&Position): u128
2StLoc[6](loc0: u128)
3CopyLoc[0](Arg0: &GlobalConfig)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5MutBorrowLoc[2](Arg2: Position)
6MoveLoc[6](loc0: u128)
7MoveLoc[4](Arg4: &Clock)
8Call pool::remove_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, &Clock): Balance<Ty0> * Balance<Ty1>
9StLoc[8](loc2: Balance<Ty1>)
10StLoc[7](loc1: Balance<Ty0>)
11CopyLoc[0](Arg0: &GlobalConfig)
12CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
13ImmBorrowLoc[2](Arg2: Position)
14LdFalse
15Call pool::collect_fee<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &Position, bool): Balance<Ty0> * Balance<Ty1>
16StLoc[10](loc4: Balance<Ty1>)
17StLoc[9](loc3: Balance<Ty0>)
18MoveLoc[3](Arg3: bool)
19BrFalse(29)
B1:
20MutBorrowLoc[7](loc1: Balance<Ty0>)
21MoveLoc[9](loc3: Balance<Ty0>)
22Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
23Pop
24MutBorrowLoc[8](loc2: Balance<Ty1>)
25MoveLoc[10](loc4: Balance<Ty1>)
26Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
27Pop
28Branch(43)
B2:
29MoveLoc[9](loc3: Balance<Ty0>)
30CopyLoc[5](Arg5: &mut TxContext)
31Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
32CopyLoc[5](Arg5: &mut TxContext)
33FreezeRef
34Call tx_context::sender(&TxContext): address
35Call utils::send_coin<Ty0>(Coin<Ty0>, address)
36MoveLoc[10](loc4: Balance<Ty1>)
37CopyLoc[5](Arg5: &mut TxContext)
38Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
39CopyLoc[5](Arg5: &mut TxContext)
40FreezeRef
41Call tx_context::sender(&TxContext): address
42Call utils::send_coin<Ty1>(Coin<Ty1>, address)
B3:
43MoveLoc[0](Arg0: &GlobalConfig)
44MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
45MoveLoc[2](Arg2: Position)
46Call pool::close_position<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Position)
47MoveLoc[7](loc1: Balance<Ty0>)
48CopyLoc[5](Arg5: &mut TxContext)
49Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
50MoveLoc[8](loc2: Balance<Ty1>)
51MoveLoc[5](Arg5: &mut TxContext)
52Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
53Ret
}
entry public collect_reward<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: &mut RewarderGlobalVault, Arg4: Coin<Ty2>, Arg5: &Clock, Arg6: &mut TxContext) {
L7: loc0: &mut RewarderGlobalVault
L8: loc1: &Clock
L9: loc2: Balance<Ty2>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut Position)
3MoveLoc[3](Arg3: &mut RewarderGlobalVault)
4MoveLoc[5](Arg5: &Clock)
5StLoc[8](loc1: &Clock)
6StLoc[7](loc0: &mut RewarderGlobalVault)
7FreezeRef
8MoveLoc[7](loc0: &mut RewarderGlobalVault)
9LdTrue
10MoveLoc[8](loc1: &Clock)
11Call pool::collect_reward<Ty0, Ty1, Ty2>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &Position, &mut RewarderGlobalVault, bool, &Clock): Balance<Ty2>
12StLoc[9](loc2: Balance<Ty2>)
13MutBorrowLoc[4](Arg4: Coin<Ty2>)
14MoveLoc[9](loc2: Balance<Ty2>)
15CopyLoc[6](Arg6: &mut TxContext)
16Call coin::from_balance<Ty2>(Balance<Ty2>, &mut TxContext): Coin<Ty2>
17Call coin::join<Ty2>(&mut Coin<Ty2>, Coin<Ty2>)
18MoveLoc[4](Arg4: Coin<Ty2>)
19MoveLoc[6](Arg6: &mut TxContext)
20FreezeRef
21Call tx_context::sender(&TxContext): address
22Call utils::send_coin<Ty2>(Coin<Ty2>, address)
23Ret
}
entry public collect_protocol_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Coin<Ty0>, Arg3: Coin<Ty1>, Arg4: &mut TxContext) {
L5: loc0: Balance<Ty0>
L6: loc1: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2CopyLoc[4](Arg4: &mut TxContext)
3FreezeRef
4Call pool::collect_protocol_fee<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &TxContext): Balance<Ty0> * Balance<Ty1>
5StLoc[6](loc1: Balance<Ty1>)
6StLoc[5](loc0: Balance<Ty0>)
7MutBorrowLoc[2](Arg2: Coin<Ty0>)
8MoveLoc[5](loc0: Balance<Ty0>)
9CopyLoc[4](Arg4: &mut TxContext)
10Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
11Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
12MutBorrowLoc[3](Arg3: Coin<Ty1>)
13MoveLoc[6](loc1: Balance<Ty1>)
14CopyLoc[4](Arg4: &mut TxContext)
15Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
16Call coin::join<Ty1>(&mut Coin<Ty1>, Coin<Ty1>)
17MoveLoc[2](Arg2: Coin<Ty0>)
18CopyLoc[4](Arg4: &mut TxContext)
19FreezeRef
20Call tx_context::sender(&TxContext): address
21Call utils::send_coin<Ty0>(Coin<Ty0>, address)
22MoveLoc[3](Arg3: Coin<Ty1>)
23MoveLoc[4](Arg4: &mut TxContext)
24FreezeRef
25Call tx_context::sender(&TxContext): address
26Call utils::send_coin<Ty1>(Coin<Ty1>, address)
27Ret
}
entry public swap_a2b<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Coin<Ty0>, Arg3: Coin<Ty1>, Arg4: bool, Arg5: u64, Arg6: u64, Arg7: u128, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: Coin<Ty0>)
3MoveLoc[3](Arg3: Coin<Ty1>)
4LdTrue
5MoveLoc[4](Arg4: bool)
6MoveLoc[5](Arg5: u64)
7MoveLoc[6](Arg6: u64)
8MoveLoc[7](Arg7: u128)
9MoveLoc[8](Arg8: &Clock)
10MoveLoc[9](Arg9: &mut TxContext)
11Call swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, bool, bool, u64, u64, u128, &Clock, &mut TxContext)
12Ret
}
entry public swap_b2a<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Coin<Ty0>, Arg3: Coin<Ty1>, Arg4: bool, Arg5: u64, Arg6: u64, Arg7: u128, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: Coin<Ty0>)
3MoveLoc[3](Arg3: Coin<Ty1>)
4LdFalse
5MoveLoc[4](Arg4: bool)
6MoveLoc[5](Arg5: u64)
7MoveLoc[6](Arg6: u64)
8MoveLoc[7](Arg7: u128)
9MoveLoc[8](Arg8: &Clock)
10MoveLoc[9](Arg9: &mut TxContext)
11Call swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, bool, bool, u64, u64, u128, &Clock, &mut TxContext)
12Ret
}
entry public swap_a2b_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Partner, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: bool, Arg6: u64, Arg7: u64, Arg8: u128, Arg9: &Clock, Arg10: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut Partner)
3MoveLoc[3](Arg3: Coin<Ty0>)
4MoveLoc[4](Arg4: Coin<Ty1>)
5LdTrue
6MoveLoc[5](Arg5: bool)
7MoveLoc[6](Arg6: u64)
8MoveLoc[7](Arg7: u64)
9MoveLoc[8](Arg8: u128)
10MoveLoc[9](Arg9: &Clock)
11MoveLoc[10](Arg10: &mut TxContext)
12Call swap_with_partner<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Partner, Coin<Ty0>, Coin<Ty1>, bool, bool, u64, u64, u128, &Clock, &mut TxContext)
13Ret
}
entry public swap_b2a_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Partner, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: bool, Arg6: u64, Arg7: u64, Arg8: u128, Arg9: &Clock, Arg10: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut Partner)
3MoveLoc[3](Arg3: Coin<Ty0>)
4MoveLoc[4](Arg4: Coin<Ty1>)
5LdFalse
6MoveLoc[5](Arg5: bool)
7MoveLoc[6](Arg6: u64)
8MoveLoc[7](Arg7: u64)
9MoveLoc[8](Arg8: u128)
10MoveLoc[9](Arg9: &Clock)
11MoveLoc[10](Arg10: &mut TxContext)
12Call swap_with_partner<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Partner, Coin<Ty0>, Coin<Ty1>, bool, bool, u64, u64, u128, &Clock, &mut TxContext)
13Ret
}
entry public update_fee_rate<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: &TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: &TxContext)
4Call pool::update_fee_rate<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, u64, &TxContext)
5Ret
}
entry public initialize_rewarder<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut TxContext)
3FreezeRef
4Call pool::initialize_rewarder<Ty0, Ty1, Ty2>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &TxContext)
5Ret
}
entry public update_rewarder_emission<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &RewarderGlobalVault, Arg3: u128, Arg4: &Clock, Arg5: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &RewarderGlobalVault)
3MoveLoc[3](Arg3: u128)
4MoveLoc[4](Arg4: &Clock)
5MoveLoc[5](Arg5: &mut TxContext)
6FreezeRef
7Call pool::update_emission<Ty0, Ty1, Ty2>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &RewarderGlobalVault, u128, &Clock, &TxContext)
8Ret
}
entry public pause_pool<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &TxContext)
3Call pool::pause<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &TxContext)
4Ret
}
entry public unpause_pool<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &TxContext)
3Call pool::unpause<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &TxContext)
4Ret
}
entry public update_position_url<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: String, Arg3: &TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: String)
3MoveLoc[3](Arg3: &TxContext)
4Call pool::update_position_url<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, String, &TxContext)
5Ret
}
repay_add_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: AddLiquidityReceipt<Ty0, Ty1>, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: u64, Arg6: u64, Arg7: &mut TxContext) {
L8: loc0: u64
L9: loc1: u64
L10: loc2: Balance<Ty0>
L11: loc3: Balance<Ty1>
B0:
0ImmBorrowLoc[2](Arg2: AddLiquidityReceipt<Ty0, Ty1>)
1Call pool::add_liquidity_pay_amount<Ty0, Ty1>(&AddLiquidityReceipt<Ty0, Ty1>): u64 * u64
2StLoc[9](loc1: u64)
3StLoc[8](loc0: u64)
4CopyLoc[8](loc0: u64)
5MoveLoc[5](Arg5: u64)
6Le
7BrFalse(9)
B1:
8Branch(17)
B2:
9MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10Pop
11MoveLoc[7](Arg7: &mut TxContext)
12Pop
13MoveLoc[0](Arg0: &GlobalConfig)
14Pop
15LdConst[0](u64: 0)
16Abort
B3:
17CopyLoc[9](loc1: u64)
18MoveLoc[6](Arg6: u64)
19Le
20BrFalse(22)
B4:
21Branch(30)
B5:
22MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
23Pop
24MoveLoc[7](Arg7: &mut TxContext)
25Pop
26MoveLoc[0](Arg0: &GlobalConfig)
27Pop
28LdConst[0](u64: 0)
29Abort
B6:
30MutBorrowLoc[3](Arg3: Coin<Ty0>)
31MoveLoc[8](loc0: u64)
32CopyLoc[7](Arg7: &mut TxContext)
33Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
34Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
35MutBorrowLoc[4](Arg4: Coin<Ty1>)
36MoveLoc[9](loc1: u64)
37CopyLoc[7](Arg7: &mut TxContext)
38Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
39Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
40StLoc[11](loc3: Balance<Ty1>)
41StLoc[10](loc2: Balance<Ty0>)
42MoveLoc[0](Arg0: &GlobalConfig)
43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
44MoveLoc[10](loc2: Balance<Ty0>)
45MoveLoc[11](loc3: Balance<Ty1>)
46MoveLoc[2](Arg2: AddLiquidityReceipt<Ty0, Ty1>)
47Call pool::repay_add_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, AddLiquidityReceipt<Ty0, Ty1>)
48MoveLoc[3](Arg3: Coin<Ty0>)
49CopyLoc[7](Arg7: &mut TxContext)
50FreezeRef
51Call tx_context::sender(&TxContext): address
52Call utils::send_coin<Ty0>(Coin<Ty0>, address)
53MoveLoc[4](Arg4: Coin<Ty1>)
54MoveLoc[7](Arg7: &mut TxContext)
55FreezeRef
56Call tx_context::sender(&TxContext): address
57Call utils::send_coin<Ty1>(Coin<Ty1>, address)
58Ret
}
entry public set_display<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &Publisher, Arg2: String, Arg3: String, Arg4: String, Arg5: String, Arg6: String, Arg7: String, Arg8: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &Publisher)
2MoveLoc[2](Arg2: String)
3MoveLoc[3](Arg3: String)
4MoveLoc[4](Arg4: String)
5MoveLoc[5](Arg5: String)
6MoveLoc[6](Arg6: String)
7MoveLoc[7](Arg7: String)
8MoveLoc[8](Arg8: &mut TxContext)
9Call pool::set_display<Ty0, Ty1>(&GlobalConfig, &Publisher, String, String, String, String, String, String, &mut TxContext)
10Ret
}
swap<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Coin<Ty0>, Arg3: Coin<Ty1>, Arg4: bool, Arg5: bool, Arg6: u64, Arg7: u64, Arg8: u128, Arg9: &Clock, Arg10: &mut TxContext) {
L11: loc0: u64
L12: loc1: u64
L13: loc2: Balance<Ty0>
L14: loc3: Balance<Ty1>
L15: loc4: FlashSwapReceipt<Ty0, Ty1>
L16: loc5: u64
L17: loc6: u64
L18: loc7: Balance<Ty0>
L19: loc8: Balance<Ty1>
L20: loc9: Balance<Ty0>
L21: loc10: Balance<Ty1>
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2CopyLoc[4](Arg4: bool)
3CopyLoc[5](Arg5: bool)
4CopyLoc[6](Arg6: u64)
5MoveLoc[8](Arg8: u128)
6MoveLoc[9](Arg9: &Clock)
7Call pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
8StLoc[15](loc4: FlashSwapReceipt<Ty0, Ty1>)
9StLoc[21](loc10: Balance<Ty1>)
10StLoc[20](loc9: Balance<Ty0>)
11ImmBorrowLoc[15](loc4: FlashSwapReceipt<Ty0, Ty1>)
12Call pool::swap_pay_amount<Ty0, Ty1>(&FlashSwapReceipt<Ty0, Ty1>): u64
13StLoc[12](loc1: u64)
14CopyLoc[4](Arg4: 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[17](loc6: u64)
26StLoc[16](loc5: u64)
27MoveLoc[5](Arg5: bool)
28BrFalse(56)
B4:
29CopyLoc[16](loc5: u64)
30MoveLoc[6](Arg6: u64)
31Eq
32BrFalse(34)
B5:
33Branch(42)
B6:
34MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
35Pop
36MoveLoc[10](Arg10: &mut TxContext)
37Pop
38MoveLoc[0](Arg0: &GlobalConfig)
39Pop
40LdConst[2](u64: 2)
41Abort
B7:
42MoveLoc[17](loc6: u64)
43MoveLoc[7](Arg7: u64)
44Ge
45BrFalse(47)
B8:
46Branch(55)
B9:
47MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
48Pop
49MoveLoc[10](Arg10: &mut TxContext)
50Pop
51MoveLoc[0](Arg0: &GlobalConfig)
52Pop
53LdConst[1](u64: 1)
54Abort
B10:
55Branch(82)
B11:
56MoveLoc[17](loc6: u64)
57MoveLoc[6](Arg6: u64)
58Eq
59BrFalse(61)
B12:
60Branch(69)
B13:
61MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
62Pop
63MoveLoc[10](Arg10: &mut TxContext)
64Pop
65MoveLoc[0](Arg0: &GlobalConfig)
66Pop
67LdConst[2](u64: 2)
68Abort
B14:
69CopyLoc[16](loc5: u64)
70MoveLoc[7](Arg7: u64)
71Le
72BrFalse(74)
B15:
73Branch(82)
B16:
74MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
75Pop
76MoveLoc[10](Arg10: &mut TxContext)
77Pop
78MoveLoc[0](Arg0: &GlobalConfig)
79Pop
80LdConst[0](u64: 0)
81Abort
B17:
82MoveLoc[4](Arg4: bool)
83BrFalse(93)
B18:
84MutBorrowLoc[2](Arg2: Coin<Ty0>)
85MoveLoc[16](loc5: u64)
86CopyLoc[10](Arg10: &mut TxContext)
87Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
88Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
89Call balance::zero<Ty1>(): Balance<Ty1>
90StLoc[14](loc3: Balance<Ty1>)
91StLoc[13](loc2: Balance<Ty0>)
92Branch(101)
B19:
93Call balance::zero<Ty0>(): Balance<Ty0>
94MutBorrowLoc[3](Arg3: Coin<Ty1>)
95MoveLoc[16](loc5: u64)
96CopyLoc[10](Arg10: &mut TxContext)
97Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
98Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
99StLoc[14](loc3: Balance<Ty1>)
100StLoc[13](loc2: Balance<Ty0>)
B20:
101MoveLoc[13](loc2: Balance<Ty0>)
102MoveLoc[14](loc3: Balance<Ty1>)
103StLoc[19](loc8: Balance<Ty1>)
104StLoc[18](loc7: Balance<Ty0>)
105MoveLoc[0](Arg0: &GlobalConfig)
106MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
107MoveLoc[18](loc7: Balance<Ty0>)
108MoveLoc[19](loc8: Balance<Ty1>)
109MoveLoc[15](loc4: FlashSwapReceipt<Ty0, Ty1>)
110Call pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
111MutBorrowLoc[3](Arg3: Coin<Ty1>)
112MoveLoc[21](loc10: Balance<Ty1>)
113CopyLoc[10](Arg10: &mut TxContext)
114Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
115Call coin::join<Ty1>(&mut Coin<Ty1>, Coin<Ty1>)
116MutBorrowLoc[2](Arg2: Coin<Ty0>)
117MoveLoc[20](loc9: Balance<Ty0>)
118CopyLoc[10](Arg10: &mut TxContext)
119Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
120Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
121MoveLoc[2](Arg2: Coin<Ty0>)
122CopyLoc[10](Arg10: &mut TxContext)
123FreezeRef
124Call tx_context::sender(&TxContext): address
125Call utils::send_coin<Ty0>(Coin<Ty0>, address)
126MoveLoc[3](Arg3: Coin<Ty1>)
127MoveLoc[10](Arg10: &mut TxContext)
128FreezeRef
129Call tx_context::sender(&TxContext): address
130Call utils::send_coin<Ty1>(Coin<Ty1>, address)
131Ret
}
swap_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Partner, Arg3: Coin<Ty0>, Arg4: Coin<Ty1>, Arg5: bool, Arg6: bool, Arg7: u64, Arg8: u64, Arg9: u128, Arg10: &Clock, Arg11: &mut TxContext) {
L12: loc0: u64
L13: loc1: Balance<Ty0>
L14: loc2: Balance<Ty1>
L15: loc3: bool
L16: loc4: bool
L17: loc5: u64
L18: loc6: u128
L19: loc7: &Clock
L20: loc8: u64
L21: loc9: FlashSwapReceipt<Ty0, Ty1>
L22: loc10: u64
L23: loc11: u64
L24: loc12: Balance<Ty0>
L25: loc13: Balance<Ty1>
L26: loc14: Balance<Ty0>
L27: loc15: Balance<Ty1>
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2CopyLoc[2](Arg2: &mut Partner)
3CopyLoc[5](Arg5: bool)
4CopyLoc[6](Arg6: bool)
5CopyLoc[7](Arg7: u64)
6MoveLoc[9](Arg9: u128)
7MoveLoc[10](Arg10: &Clock)
8StLoc[19](loc7: &Clock)
9StLoc[18](loc6: u128)
10StLoc[17](loc5: u64)
11StLoc[16](loc4: bool)
12StLoc[15](loc3: bool)
13FreezeRef
14MoveLoc[15](loc3: bool)
15MoveLoc[16](loc4: bool)
16MoveLoc[17](loc5: u64)
17MoveLoc[18](loc6: u128)
18MoveLoc[19](loc7: &Clock)
19Call pool::flash_swap_with_partner<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &Partner, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
20StLoc[21](loc9: FlashSwapReceipt<Ty0, Ty1>)
21StLoc[27](loc15: Balance<Ty1>)
22StLoc[26](loc14: Balance<Ty0>)
23ImmBorrowLoc[21](loc9: FlashSwapReceipt<Ty0, Ty1>)
24Call pool::swap_pay_amount<Ty0, Ty1>(&FlashSwapReceipt<Ty0, Ty1>): u64
25StLoc[12](loc0: u64)
26CopyLoc[5](Arg5: bool)
27BrFalse(32)
B1:
28ImmBorrowLoc[27](loc15: Balance<Ty1>)
29Call balance::value<Ty1>(&Balance<Ty1>): u64
30StLoc[20](loc8: u64)
31Branch(35)
B2:
32ImmBorrowLoc[26](loc14: Balance<Ty0>)
33Call balance::value<Ty0>(&Balance<Ty0>): u64
34StLoc[20](loc8: u64)
B3:
35MoveLoc[12](loc0: u64)
36MoveLoc[20](loc8: u64)
37StLoc[23](loc11: u64)
38StLoc[22](loc10: u64)
39MoveLoc[6](Arg6: bool)
40BrFalse(72)
B4:
41CopyLoc[22](loc10: u64)
42MoveLoc[7](Arg7: u64)
43Eq
44BrFalse(46)
B5:
45Branch(56)
B6:
46MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
47Pop
48MoveLoc[2](Arg2: &mut Partner)
49Pop
50MoveLoc[11](Arg11: &mut TxContext)
51Pop
52MoveLoc[0](Arg0: &GlobalConfig)
53Pop
54LdConst[2](u64: 2)
55Abort
B7:
56MoveLoc[23](loc11: u64)
57MoveLoc[8](Arg8: u64)
58Ge
59BrFalse(61)
B8:
60Branch(71)
B9:
61MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
62Pop
63MoveLoc[2](Arg2: &mut Partner)
64Pop
65MoveLoc[11](Arg11: &mut TxContext)
66Pop
67MoveLoc[0](Arg0: &GlobalConfig)
68Pop
69LdConst[1](u64: 1)
70Abort
B10:
71Branch(102)
B11:
72MoveLoc[23](loc11: u64)
73MoveLoc[7](Arg7: u64)
74Eq
75BrFalse(77)
B12:
76Branch(87)
B13:
77MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
78Pop
79MoveLoc[2](Arg2: &mut Partner)
80Pop
81MoveLoc[11](Arg11: &mut TxContext)
82Pop
83MoveLoc[0](Arg0: &GlobalConfig)
84Pop
85LdConst[2](u64: 2)
86Abort
B14:
87CopyLoc[22](loc10: u64)
88MoveLoc[8](Arg8: u64)
89Le
90BrFalse(92)
B15:
91Branch(102)
B16:
92MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
93Pop
94MoveLoc[2](Arg2: &mut Partner)
95Pop
96MoveLoc[11](Arg11: &mut TxContext)
97Pop
98MoveLoc[0](Arg0: &GlobalConfig)
99Pop
100LdConst[0](u64: 0)
101Abort
B17:
102MoveLoc[5](Arg5: bool)
103BrFalse(113)
B18:
104MutBorrowLoc[3](Arg3: Coin<Ty0>)
105MoveLoc[22](loc10: u64)
106CopyLoc[11](Arg11: &mut TxContext)
107Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
108Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
109Call balance::zero<Ty1>(): Balance<Ty1>
110StLoc[14](loc2: Balance<Ty1>)
111StLoc[13](loc1: Balance<Ty0>)
112Branch(121)
B19:
113Call balance::zero<Ty0>(): Balance<Ty0>
114MutBorrowLoc[4](Arg4: Coin<Ty1>)
115MoveLoc[22](loc10: u64)
116CopyLoc[11](Arg11: &mut TxContext)
117Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
118Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
119StLoc[14](loc2: Balance<Ty1>)
120StLoc[13](loc1: Balance<Ty0>)
B20:
121MoveLoc[13](loc1: Balance<Ty0>)
122MoveLoc[14](loc2: Balance<Ty1>)
123StLoc[25](loc13: Balance<Ty1>)
124StLoc[24](loc12: Balance<Ty0>)
125MoveLoc[0](Arg0: &GlobalConfig)
126MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
127MoveLoc[2](Arg2: &mut Partner)
128MoveLoc[24](loc12: Balance<Ty0>)
129MoveLoc[25](loc13: Balance<Ty1>)
130MoveLoc[21](loc9: FlashSwapReceipt<Ty0, Ty1>)
131Call pool::repay_flash_swap_with_partner<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Partner, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
132MutBorrowLoc[4](Arg4: Coin<Ty1>)
133MoveLoc[27](loc15: Balance<Ty1>)
134CopyLoc[11](Arg11: &mut TxContext)
135Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
136Call coin::join<Ty1>(&mut Coin<Ty1>, Coin<Ty1>)
137MutBorrowLoc[3](Arg3: Coin<Ty0>)
138MoveLoc[26](loc14: Balance<Ty0>)
139CopyLoc[11](Arg11: &mut TxContext)
140Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
141Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
142MoveLoc[3](Arg3: Coin<Ty0>)
143CopyLoc[11](Arg11: &mut TxContext)
144FreezeRef
145Call tx_context::sender(&TxContext): address
146Call utils::send_coin<Ty0>(Coin<Ty0>, address)
147MoveLoc[4](Arg4: Coin<Ty1>)
148MoveLoc[11](Arg11: &mut TxContext)
149FreezeRef
150Call tx_context::sender(&TxContext): address
151Call utils::send_coin<Ty1>(Coin<Ty1>, address)
152Ret
}
Constants [
0 => u64: 0
1 => u64: 1
2 => u64: 2
]
}