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