pool
Module0x2606…f084
- Move path
- 0x1eab…b2fb::pool
- Functions
- 11498 public, 2 entry
- Structs
- 27
- Friend modules
- factory
pool
Bytecode5072 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb.pool {
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::clmm_math;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::config;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::partner;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::position;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::position_snapshot;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::rewarder;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::tick;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::tick_math;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::full_math_u64;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i128;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i32;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::math_u128;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::math_u64;
use be21a06129308e0495431d12286127897aff07a8ade3970495a4404d97f9eaaa::option_u64;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::display;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct POOL has drop {
dummy_field: bool
}
struct ProtocolFeeCollectCap has store, key {
id: UID
}
struct Pool<phantom Ty0, phantom Ty1> has store, key {
id: UID,
coin_a: Balance<Ty0>,
coin_b: Balance<Ty1>,
tick_spacing: u32,
fee_rate: u64,
liquidity: u128,
current_sqrt_price: u128,
current_tick_index: I32,
fee_growth_global_a: u128,
fee_growth_global_b: u128,
fee_protocol_coin_a: u64,
fee_protocol_coin_b: u64,
tick_manager: TickManager,
rewarder_manager: RewarderManager,
position_manager: PositionManager,
is_pause: bool,
index: u64,
url: String
}
struct Status has copy, drop, store {
disable_add_liquidity: bool,
disable_remove_liquidity: bool,
disable_swap: bool,
disable_flash_loan: bool,
disable_collect_fee: bool,
disable_collect_reward: bool
}
struct PoolStatus has store, key {
id: UID,
status: Status
}
struct SwapResult has copy, drop {
amount_in: u64,
amount_out: u64,
fee_amount: u64,
ref_fee_amount: u64,
steps: u64
}
struct FlashSwapReceipt<phantom Ty0, phantom Ty1> {
pool_id: ID,
a2b: bool,
partner_id: ID,
pay_amount: u64,
ref_fee_amount: u64
}
struct AddLiquidityReceipt<phantom Ty0, phantom Ty1> {
pool_id: ID,
amount_a: u64,
amount_b: u64
}
struct FlashLoanReceipt {
pool_id: ID,
loan_a: bool,
partner_id: ID,
amount: u64,
fee_amount: u64,
ref_fee_amount: u64
}
struct CalculatedSwapResult has copy, drop, store {
amount_in: u64,
amount_out: u64,
fee_amount: u64,
fee_rate: u64,
after_sqrt_price: u128,
is_exceed: bool,
step_results: vector<SwapStepResult>
}
struct SwapStepResult has copy, drop, store {
current_sqrt_price: u128,
target_sqrt_price: u128,
current_liquidity: u128,
amount_in: u64,
amount_out: u64,
fee_amount: u64,
remainder_amount: u64
}
struct OpenPositionEvent has copy, drop, store {
pool: ID,
tick_lower: I32,
tick_upper: I32,
position: ID
}
struct ClosePositionEvent has copy, drop, store {
pool: ID,
position: ID
}
struct AddLiquidityEvent has copy, drop, store {
pool: ID,
position: ID,
tick_lower: I32,
tick_upper: I32,
liquidity: u128,
after_liquidity: u128,
amount_a: u64,
amount_b: u64
}
struct AddLiquidityV2Event has copy, drop, store {
pool: ID,
position: ID,
tick_lower: I32,
tick_upper: I32,
liquidity: u128,
after_liquidity: u128,
current_sqrt_price: u128,
amount_a: u64,
amount_b: u64
}
struct RemoveLiquidityV2Event has copy, drop, store {
pool: ID,
position: ID,
tick_lower: I32,
tick_upper: I32,
liquidity: u128,
after_liquidity: u128,
current_sqrt_price: u128,
amount_a: u64,
amount_b: u64
}
struct RemoveLiquidityEvent has copy, drop, store {
pool: ID,
position: ID,
tick_lower: I32,
tick_upper: I32,
liquidity: u128,
after_liquidity: u128,
amount_a: u64,
amount_b: u64
}
struct SwapEvent has copy, drop, store {
atob: bool,
pool: ID,
partner: ID,
amount_in: u64,
amount_out: u64,
ref_amount: u64,
fee_amount: u64,
vault_a_amount: u64,
vault_b_amount: u64,
before_sqrt_price: u128,
after_sqrt_price: u128,
steps: u64
}
struct CollectProtocolFeeEvent has copy, drop, store {
pool: ID,
amount_a: u64,
amount_b: u64
}
struct CollectFeeEvent has copy, drop, store {
position: ID,
pool: ID,
amount_a: u64,
amount_b: u64
}
struct UpdateFeeRateEvent has copy, drop, store {
pool: ID,
old_fee_rate: u64,
new_fee_rate: u64
}
struct UpdateEmissionEvent has copy, drop, store {
pool: ID,
rewarder_type: TypeName,
emissions_per_second: u128
}
struct AddRewarderEvent has copy, drop, store {
pool: ID,
rewarder_type: TypeName
}
struct CollectRewardEvent has copy, drop, store {
position: ID,
pool: ID,
amount: u64
}
struct CollectRewardV2Event has copy, drop, store {
position: ID,
pool: ID,
rewarder_type: TypeName,
amount: u64
}
struct FlashLoanEvent has copy, drop, store {
pool: ID,
loan_a: bool,
partner: ID,
amount: u64,
fee_amount: u64,
ref_amount: u64,
vault_a_amount: u64,
vault_b_amount: u64
}
struct UpdatePoolStatusEvent has copy, drop, store {
pool: ID,
is_pause_before: bool,
is_pause_after: bool,
before_status: Option<Status>,
after_status: Status
}
init(Arg0: POOL, Arg1: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: POOL)
1CopyLoc[1](Arg1: &mut TxContext)
2Call package::claim<POOL>(POOL, &mut TxContext): Publisher
3MoveLoc[1](Arg1: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Call transfer::public_transfer<Publisher>(Publisher, address)
7Ret
}
entry public mint_protocol_fee_collect_cap(Arg0: &AdminCap, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[2](Arg2: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Pack[1](ProtocolFeeCollectCap)
3MoveLoc[1](Arg1: address)
4Call transfer::transfer<ProtocolFeeCollectCap>(ProtocolFeeCollectCap, address)
5Ret
}
public(friend) new<Ty0, Ty1>(Arg0: u32, Arg1: u128, Arg2: u64, Arg3: String, Arg4: u64, Arg5: &Clock, Arg6: &mut TxContext): Pool<Ty0, Ty1> {
B0:
0CopyLoc[6](Arg6: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Call balance::zero<Ty0>(): Balance<Ty0>
3Call balance::zero<Ty1>(): Balance<Ty1>
4CopyLoc[0](Arg0: u32)
5MoveLoc[2](Arg2: u64)
6LdU128(0)
7CopyLoc[1](Arg1: u128)
8MoveLoc[1](Arg1: u128)
9Call tick_math::get_tick_at_sqrt_price(u128): I32
10LdU128(0)
11LdU128(0)
12LdU64(0)
13LdU64(0)
14CopyLoc[0](Arg0: u32)
15MoveLoc[5](Arg5: &Clock)
16Call clock::timestamp_ms(&Clock): u64
17CopyLoc[6](Arg6: &mut TxContext)
18Call tick::new(u32, u64, &mut TxContext): TickManager
19Call rewarder::new(): RewarderManager
20MoveLoc[0](Arg0: u32)
21MoveLoc[6](Arg6: &mut TxContext)
22Call position::new(u32, &mut TxContext): PositionManager
23LdFalse
24MoveLoc[4](Arg4: u64)
25MoveLoc[3](Arg3: String)
26PackGeneric[0](Pool<Ty0, Ty1>)
27Ret
}
public set_display<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &Publisher, Arg2: String, Arg3: String, Arg4: String, Arg5: String, Arg6: String, Arg7: String, Arg8: &mut TxContext) {
L9: loc0: String
L10: loc1: String
L11: loc2: Display<Pool<Ty0, Ty1>>
L12: loc3: vector<String>
L13: loc4: vector<String>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &Publisher)
3Call package::from_module<Pool<Ty0, Ty1>>(&Publisher): bool
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[1](Arg1: &Publisher)
7Pop
8MoveLoc[8](Arg8: &mut TxContext)
9Pop
10LdConst[32](u64: 26)
11Abort
B3:
12LdConst[43](vector<u8>: "nam..)
13Call string::utf8(vector<u8>): String
14LdConst[44](vector<u8>: "coi..)
15Call string::utf8(vector<u8>): String
16LdConst[45](vector<u8>: "coi..)
17Call string::utf8(vector<u8>): String
18LdConst[46](vector<u8>: "lin..)
19Call string::utf8(vector<u8>): String
20LdConst[47](vector<u8>: "ima..)
21Call string::utf8(vector<u8>): String
22LdConst[48](vector<u8>: "des..)
23Call string::utf8(vector<u8>): String
24LdConst[49](vector<u8>: "pro..)
25Call string::utf8(vector<u8>): String
26LdConst[50](vector<u8>: "cre..)
27Call string::utf8(vector<u8>): String
28VecPack(72, 8)
29StLoc[12](loc3: vector<String>)
30Call type_name::with_defining_ids<Ty0>(): TypeName
31Call type_name::into_string(TypeName): String
32Call string::from_ascii(String): String
33StLoc[9](loc0: String)
34Call type_name::with_defining_ids<Ty1>(): TypeName
35Call type_name::into_string(TypeName): String
36Call string::from_ascii(String): String
37StLoc[10](loc1: String)
38MoveLoc[2](Arg2: String)
39MoveLoc[9](loc0: String)
40MoveLoc[10](loc1: String)
41MoveLoc[5](Arg5: String)
42MoveLoc[4](Arg4: String)
43MoveLoc[3](Arg3: String)
44MoveLoc[6](Arg6: String)
45MoveLoc[7](Arg7: String)
46VecPack(72, 8)
47StLoc[13](loc4: vector<String>)
48MoveLoc[1](Arg1: &Publisher)
49MoveLoc[12](loc3: vector<String>)
50MoveLoc[13](loc4: vector<String>)
51CopyLoc[8](Arg8: &mut TxContext)
52Call display::new_with_fields<Pool<Ty0, Ty1>>(&Publisher, vector<String>, vector<String>, &mut TxContext): Display<Pool<Ty0, Ty1>>
53StLoc[11](loc2: Display<Pool<Ty0, Ty1>>)
54MutBorrowLoc[11](loc2: Display<Pool<Ty0, Ty1>>)
55Call display::update_version<Pool<Ty0, Ty1>>(&mut Display<Pool<Ty0, Ty1>>)
56MoveLoc[11](loc2: Display<Pool<Ty0, Ty1>>)
57MoveLoc[8](Arg8: &mut TxContext)
58FreezeRef
59Call tx_context::sender(&TxContext): address
60Call transfer::public_transfer<Display<Pool<Ty0, Ty1>>>(Display<Pool<Ty0, Ty1>>, address)
61Ret
}
public open_position<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u32, Arg3: u32, Arg4: &mut TxContext): Position {
L5: loc0: ID
L6: loc1: I32
L7: loc2: I32
L8: loc3: ID
L9: loc4: ID
L10: loc5: Position
L11: loc6: ID
L12: loc7: I32
L13: loc8: I32
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_add_liquidity<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9MoveLoc[4](Arg4: &mut TxContext)
10Pop
11LdConst[31](u64: 25)
12Abort
B3:
13MoveLoc[2](Arg2: u32)
14Call i32::from_u32(u32): I32
15StLoc[12](loc7: I32)
16MoveLoc[3](Arg3: u32)
17Call i32::from_u32(u32): I32
18StLoc[13](loc8: I32)
19CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
20FreezeRef
21Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
22StLoc[9](loc4: ID)
23CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
25CopyLoc[9](loc4: ID)
26CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
27ImmBorrowFieldGeneric[1](Pool.index: u64)
28ReadRef
29MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
30ImmBorrowFieldGeneric[2](Pool.url: String)
31ReadRef
32CopyLoc[12](loc7: I32)
33CopyLoc[13](loc8: I32)
34MoveLoc[4](Arg4: &mut TxContext)
35Call position::open_position<Ty0, Ty1>(&mut PositionManager, ID, u64, String, I32, I32, &mut TxContext): Position
36StLoc[10](loc5: Position)
37ImmBorrowLoc[10](loc5: Position)
38Call object::id<Position>(&Position): ID
39StLoc[11](loc6: ID)
40MoveLoc[9](loc4: ID)
41StLoc[5](loc0: ID)
42MoveLoc[13](loc8: I32)
43StLoc[6](loc1: I32)
44MoveLoc[12](loc7: I32)
45StLoc[7](loc2: I32)
46MoveLoc[11](loc6: ID)
47StLoc[8](loc3: ID)
48MoveLoc[5](loc0: ID)
49MoveLoc[7](loc2: I32)
50MoveLoc[6](loc1: I32)
51MoveLoc[8](loc3: ID)
52Pack[11](OpenPositionEvent)
53Call event::emit<OpenPositionEvent>(OpenPositionEvent)
54MoveLoc[10](loc5: Position)
55Ret
}
public add_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: u128, Arg4: &Clock): AddLiquidityReceipt<Ty0, Ty1> {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[3](Arg3: u128)
3LdU128(0)
4Neq
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[2](Arg2: &mut Position)
8Pop
9MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10Pop
11MoveLoc[4](Arg4: &Clock)
12Pop
13LdConst[9](u64: 3)
14Abort
B3:
15CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16FreezeRef
17Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
18CopyLoc[2](Arg2: &mut Position)
19FreezeRef
20Call position::pool_id(&Position): ID
21Eq
22BrFalse(24)
B4:
23Branch(32)
B5:
24MoveLoc[2](Arg2: &mut Position)
25Pop
26MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
27Pop
28MoveLoc[4](Arg4: &Clock)
29Pop
30LdConst[25](u64: 19)
31Abort
B6:
32MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
33MoveLoc[2](Arg2: &mut Position)
34LdFalse
35MoveLoc[3](Arg3: u128)
36LdU64(0)
37LdFalse
38MoveLoc[4](Arg4: &Clock)
39Call clock::timestamp_ms(&Clock): u64
40LdU64(1000)
41Div
42Call add_liquidity_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut Position, bool, u128, u64, bool, u64): AddLiquidityReceipt<Ty0, Ty1>
43Ret
}
public add_liquidity_fix_coin<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: u64, Arg4: bool, Arg5: &Clock): AddLiquidityReceipt<Ty0, Ty1> {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[3](Arg3: u64)
3LdU64(0)
4Gt
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[2](Arg2: &mut Position)
8Pop
9MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10Pop
11MoveLoc[5](Arg5: &Clock)
12Pop
13LdConst[6](u64: 0)
14Abort
B3:
15CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16FreezeRef
17Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
18CopyLoc[2](Arg2: &mut Position)
19FreezeRef
20Call position::pool_id(&Position): ID
21Eq
22BrFalse(24)
B4:
23Branch(32)
B5:
24MoveLoc[2](Arg2: &mut Position)
25Pop
26MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
27Pop
28MoveLoc[5](Arg5: &Clock)
29Pop
30LdConst[25](u64: 19)
31Abort
B6:
32MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
33MoveLoc[2](Arg2: &mut Position)
34LdTrue
35LdU128(0)
36MoveLoc[3](Arg3: u64)
37MoveLoc[4](Arg4: bool)
38MoveLoc[5](Arg5: &Clock)
39Call clock::timestamp_ms(&Clock): u64
40LdU64(1000)
41Div
42Call add_liquidity_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut Position, bool, u128, u64, bool, u64): AddLiquidityReceipt<Ty0, Ty1>
43Ret
}
public add_liquidity_pay_amount<Ty0, Ty1>(Arg0: &AddLiquidityReceipt<Ty0, Ty1>): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &AddLiquidityReceipt<Ty0, Ty1>)
1ImmBorrowFieldGeneric[3](AddLiquidityReceipt.amount_a: u64)
2ReadRef
3MoveLoc[0](Arg0: &AddLiquidityReceipt<Ty0, Ty1>)
4ImmBorrowFieldGeneric[4](AddLiquidityReceipt.amount_b: u64)
5ReadRef
6Ret
}
public repay_add_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: Balance<Ty1>, Arg4: AddLiquidityReceipt<Ty0, Ty1>) {
L5: loc0: u64
L6: loc1: u64
L7: loc2: ID
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[4](Arg4: AddLiquidityReceipt<Ty0, Ty1>)
3UnpackGeneric[1](AddLiquidityReceipt<Ty0, Ty1>)
4StLoc[6](loc1: u64)
5StLoc[5](loc0: u64)
6StLoc[7](loc2: ID)
7ImmBorrowLoc[2](Arg2: Balance<Ty0>)
8Call balance::value<Ty0>(&Balance<Ty0>): u64
9MoveLoc[5](loc0: u64)
10Eq
11BrFalse(13)
B1:
12Branch(17)
B2:
13MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
14Pop
15LdConst[6](u64: 0)
16Abort
B3:
17ImmBorrowLoc[3](Arg3: Balance<Ty1>)
18Call balance::value<Ty1>(&Balance<Ty1>): u64
19MoveLoc[6](loc1: u64)
20Eq
21BrFalse(23)
B4:
22Branch(27)
B5:
23MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24Pop
25LdConst[6](u64: 0)
26Abort
B6:
27CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
28FreezeRef
29Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
30MoveLoc[7](loc2: ID)
31Eq
32BrFalse(34)
B7:
33Branch(38)
B8:
34MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
35Pop
36LdConst[18](u64: 12)
37Abort
B9:
38CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
39Call clear_pending_add_liquidity<Ty0, Ty1>(&mut Pool<Ty0, Ty1>)
40CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
41MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
42MoveLoc[2](Arg2: Balance<Ty0>)
43Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
44Pop
45MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
46MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
47MoveLoc[3](Arg3: Balance<Ty1>)
48Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
49Pop
50Ret
}
public remove_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: u128, Arg4: &Clock): Balance<Ty0> * Balance<Ty1> {
L5: loc0: bool
L6: loc1: u128
L7: loc2: u64
L8: loc3: u64
L9: loc4: Balance<Ty0>
L10: loc5: Balance<Ty1>
L11: loc6: u128
L12: loc7: u128
L13: loc8: u128
L14: loc9: vector<u128>
L15: loc10: I32
L16: loc11: I32
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_remove_liquidity<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[2](Arg2: &mut Position)
8Pop
9MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10Pop
11MoveLoc[4](Arg4: &Clock)
12Pop
13LdConst[31](u64: 25)
14Abort
B3:
15CopyLoc[3](Arg3: u128)
16LdU128(0)
17Gt
18BrFalse(20)
B4:
19Branch(28)
B5:
20MoveLoc[2](Arg2: &mut Position)
21Pop
22MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
23Pop
24MoveLoc[4](Arg4: &Clock)
25Pop
26LdConst[9](u64: 3)
27Abort
B6:
28CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
29FreezeRef
30Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
31CopyLoc[2](Arg2: &mut Position)
32FreezeRef
33Call position::pool_id(&Position): ID
34Eq
35BrFalse(37)
B7:
36Branch(45)
B8:
37MoveLoc[2](Arg2: &mut Position)
38Pop
39MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
40Pop
41MoveLoc[4](Arg4: &Clock)
42Pop
43LdConst[25](u64: 19)
44Abort
B9:
45CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
46FreezeRef
47Call assert_no_pending_add_liquidity<Ty0, Ty1>(&Pool<Ty0, Ty1>)
48CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
49MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
50CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
51ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
52ReadRef
53MoveLoc[4](Arg4: &Clock)
54Call clock::timestamp_ms(&Clock): u64
55LdU64(1000)
56Div
57Call rewarder::settle(&mut RewarderManager, u128, u64)
58CopyLoc[2](Arg2: &mut Position)
59FreezeRef
60Call position::tick_range(&Position): I32 * I32
61StLoc[16](loc11: I32)
62StLoc[15](loc10: I32)
63CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
64FreezeRef
65CopyLoc[15](loc10: I32)
66CopyLoc[16](loc11: I32)
67Call get_fee_rewards_points_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128 * vector<u128> * u128
68StLoc[13](loc8: u128)
69StLoc[14](loc9: vector<u128>)
70StLoc[12](loc7: u128)
71StLoc[11](loc6: u128)
72CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
73MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
74CopyLoc[2](Arg2: &mut Position)
75CopyLoc[3](Arg3: u128)
76MoveLoc[11](loc6: u128)
77MoveLoc[12](loc7: u128)
78MoveLoc[13](loc8: u128)
79MoveLoc[14](loc9: vector<u128>)
80Call position::decrease_liquidity(&mut PositionManager, &mut Position, u128, u128, u128, u128, vector<u128>): u128
81StLoc[6](loc1: u128)
82CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
83MutBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
84CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
85ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
86ReadRef
87CopyLoc[15](loc10: I32)
88CopyLoc[16](loc11: I32)
89CopyLoc[3](Arg3: u128)
90CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
91ImmBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
92ReadRef
93CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
94ImmBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
95ReadRef
96CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
97ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
98Call rewarder::points_growth_global(&RewarderManager): u128
99CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
100ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
101Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>
102Call tick::decrease_liquidity(&mut TickManager, I32, I32, I32, u128, u128, u128, u128, vector<u128>)
103CopyLoc[15](loc10: I32)
104CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
105ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
106ReadRef
107Call i32::lte(I32, I32): bool
108BrFalse(116)
B10:
109CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
110ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
111ReadRef
112CopyLoc[16](loc11: I32)
113Call i32::lt(I32, I32): bool
114StLoc[5](loc0: bool)
115Branch(118)
B11:
116LdFalse
117StLoc[5](loc0: bool)
B12:
118MoveLoc[5](loc0: bool)
119BrFalse(128)
B13:
120CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
121ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
122ReadRef
123CopyLoc[3](Arg3: u128)
124Sub
125CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
126MutBorrowFieldGeneric[8](Pool.liquidity: u128)
127WriteRef
B14:
128CopyLoc[15](loc10: I32)
129CopyLoc[16](loc11: I32)
130CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
131ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
132ReadRef
133CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
134ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
135ReadRef
136CopyLoc[3](Arg3: u128)
137LdFalse
138Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64
139StLoc[8](loc3: u64)
140StLoc[7](loc2: u64)
141CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
142MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
143CopyLoc[7](loc2: u64)
144Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
145CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
146MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
147CopyLoc[8](loc3: u64)
148Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
149StLoc[10](loc5: Balance<Ty1>)
150StLoc[9](loc4: Balance<Ty0>)
151CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
152FreezeRef
153Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
154MoveLoc[2](Arg2: &mut Position)
155FreezeRef
156Call object::id<Position>(&Position): ID
157MoveLoc[15](loc10: I32)
158MoveLoc[16](loc11: I32)
159MoveLoc[3](Arg3: u128)
160MoveLoc[6](loc1: u128)
161MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
162ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
163ReadRef
164MoveLoc[7](loc2: u64)
165MoveLoc[8](loc3: u64)
166Pack[15](RemoveLiquidityV2Event)
167Call event::emit<RemoveLiquidityV2Event>(RemoveLiquidityV2Event)
168MoveLoc[9](loc4: Balance<Ty0>)
169MoveLoc[10](loc5: Balance<Ty1>)
170Ret
}
public remove_liquidity_with_slippage<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: u128, Arg4: u64, Arg5: u64, Arg6: &Clock): Balance<Ty0> * Balance<Ty1> {
L7: loc0: Balance<Ty0>
L8: loc1: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut Position)
3MoveLoc[3](Arg3: u128)
4MoveLoc[6](Arg6: &Clock)
5Call remove_liquidity<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, u128, &Clock): Balance<Ty0> * Balance<Ty1>
6StLoc[8](loc1: Balance<Ty1>)
7StLoc[7](loc0: Balance<Ty0>)
8ImmBorrowLoc[7](loc0: Balance<Ty0>)
9Call balance::value<Ty0>(&Balance<Ty0>): u64
10MoveLoc[4](Arg4: u64)
11Ge
12BrFalse(14)
B1:
13Branch(16)
B2:
14LdConst[42](u64: 36)
15Abort
B3:
16ImmBorrowLoc[8](loc1: Balance<Ty1>)
17Call balance::value<Ty1>(&Balance<Ty1>): u64
18MoveLoc[5](Arg5: u64)
19Ge
20BrFalse(22)
B4:
21Branch(24)
B5:
22LdConst[42](u64: 36)
23Abort
B6:
24MoveLoc[7](loc0: Balance<Ty0>)
25MoveLoc[8](loc1: Balance<Ty1>)
26Ret
}
public close_position<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Position) {
L3: loc0: ID
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_remove_liquidity<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9LdConst[31](u64: 25)
10Abort
B3:
11CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
12FreezeRef
13Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
14ImmBorrowLoc[2](Arg2: Position)
15Call position::pool_id(&Position): ID
16Eq
17BrFalse(19)
B4:
18Branch(23)
B5:
19MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
20Pop
21LdConst[25](u64: 19)
22Abort
B6:
23ImmBorrowLoc[2](Arg2: Position)
24Call object::id<Position>(&Position): ID
25StLoc[3](loc0: ID)
26CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
27ImmBorrowFieldGeneric[14](Pool.id: UID)
28LdConst[3](vector<u8>: "pos..)
29Call string::utf8(vector<u8>): String
30Call dynamic_object_field::exists_<String>(&UID, String): bool
31BrFalse(47)
B7:
32CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
33MutBorrowFieldGeneric[14](Pool.id: UID)
34LdConst[3](vector<u8>: "pos..)
35Call string::utf8(vector<u8>): String
36Call dynamic_object_field::borrow_mut<String, PositionLiquiditySnapshot>(&mut UID, String): &mut PositionLiquiditySnapshot
37FreezeRef
38CopyLoc[3](loc0: ID)
39Call position_snapshot::contains(&PositionLiquiditySnapshot, ID): bool
40Not
41BrFalse(43)
B8:
42Branch(47)
B9:
43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
44Pop
45LdConst[29](u64: 23)
46Abort
B10:
47CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
48MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
49MoveLoc[2](Arg2: Position)
50Call position::close_position(&mut PositionManager, Position)
51MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
52FreezeRef
53Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
54MoveLoc[3](loc0: ID)
55Pack[12](ClosePositionEvent)
56Call event::emit<ClosePositionEvent>(ClosePositionEvent)
57Ret
}
public collect_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Position, Arg3: bool): Balance<Ty0> * Balance<Ty1> {
L4: loc0: bool
L5: loc1: u64
L6: loc2: u64
L7: loc3: ID
L8: loc4: u64
L9: loc5: u64
L10: loc6: u64
L11: loc7: u64
L12: loc8: Balance<Ty0>
L13: loc9: Balance<Ty1>
L14: loc10: u128
L15: loc11: u128
L16: loc12: u128
L17: loc13: ID
L18: loc14: I32
L19: loc15: I32
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_collect_fee<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[2](Arg2: &Position)
8Pop
9MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10Pop
11LdConst[31](u64: 25)
12Abort
B3:
13CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
14FreezeRef
15Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
16CopyLoc[2](Arg2: &Position)
17Call position::pool_id(&Position): ID
18Eq
19BrFalse(21)
B4:
20Branch(27)
B5:
21MoveLoc[2](Arg2: &Position)
22Pop
23MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24Pop
25LdConst[25](u64: 19)
26Abort
B6:
27CopyLoc[2](Arg2: &Position)
28Call object::id<Position>(&Position): ID
29StLoc[17](loc13: ID)
30CopyLoc[2](Arg2: &Position)
31Call position::liquidity(&Position): u128
32StLoc[16](loc12: u128)
33MoveLoc[2](Arg2: &Position)
34Call position::tick_range(&Position): I32 * I32
35StLoc[19](loc15: I32)
36StLoc[18](loc14: I32)
37MoveLoc[3](Arg3: bool)
38BrFalse(44)
B7:
39MoveLoc[16](loc12: u128)
40LdU128(0)
41Neq
42StLoc[4](loc0: bool)
43Branch(46)
B8:
44LdFalse
45StLoc[4](loc0: bool)
B9:
46MoveLoc[4](loc0: bool)
47BrFalse(64)
B10:
48CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
49FreezeRef
50MoveLoc[18](loc14: I32)
51MoveLoc[19](loc15: I32)
52Call get_fee_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128
53StLoc[15](loc11: u128)
54StLoc[14](loc10: u128)
55CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
56MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
57CopyLoc[17](loc13: ID)
58MoveLoc[14](loc10: u128)
59MoveLoc[15](loc11: u128)
60Call position::update_and_reset_fee(&mut PositionManager, ID, u128, u128): u64 * u64
61StLoc[6](loc2: u64)
62StLoc[5](loc1: u64)
63Branch(70)
B11:
64CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
65MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
66CopyLoc[17](loc13: ID)
67Call position::reset_fee(&mut PositionManager, ID): u64 * u64
68StLoc[6](loc2: u64)
69StLoc[5](loc1: u64)
B12:
70MoveLoc[5](loc1: u64)
71MoveLoc[6](loc2: u64)
72StLoc[11](loc7: u64)
73StLoc[10](loc6: u64)
74CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
75MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
76CopyLoc[10](loc6: u64)
77Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
78StLoc[12](loc8: Balance<Ty0>)
79CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
80MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
81CopyLoc[11](loc7: u64)
82Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
83StLoc[13](loc9: Balance<Ty1>)
84MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
85FreezeRef
86Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
87StLoc[7](loc3: ID)
88MoveLoc[10](loc6: u64)
89StLoc[8](loc4: u64)
90MoveLoc[11](loc7: u64)
91StLoc[9](loc5: u64)
92MoveLoc[17](loc13: ID)
93MoveLoc[7](loc3: ID)
94MoveLoc[8](loc4: u64)
95MoveLoc[9](loc5: u64)
96Pack[19](CollectFeeEvent)
97Call event::emit<CollectFeeEvent>(CollectFeeEvent)
98MoveLoc[12](loc8: Balance<Ty0>)
99MoveLoc[13](loc9: Balance<Ty1>)
100Ret
}
public collect_reward<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Position, Arg3: &mut RewarderGlobalVault, Arg4: bool, Arg5: &Clock): Balance<Ty2> {
L6: loc0: bool
L7: loc1: bool
L8: loc2: u64
L9: loc3: ID
L10: loc4: ID
L11: loc5: TypeName
L12: loc6: u64
L13: loc7: Balance<Ty2>
L14: loc8: u64
L15: loc9: Option<u64>
L16: loc10: ID
L17: loc11: u128
L18: loc12: u64
L19: loc13: u64
L20: loc14: vector<u128>
L21: loc15: I32
L22: loc16: I32
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_collect_reward<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(17)
B2:
7MoveLoc[3](Arg3: &mut RewarderGlobalVault)
8Pop
9MoveLoc[2](Arg2: &Position)
10Pop
11MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
12Pop
13MoveLoc[5](Arg5: &Clock)
14Pop
15LdConst[31](u64: 25)
16Abort
B3:
17CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
18FreezeRef
19Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
20CopyLoc[2](Arg2: &Position)
21Call position::pool_id(&Position): ID
22Eq
23BrFalse(25)
B4:
24Branch(35)
B5:
25MoveLoc[3](Arg3: &mut RewarderGlobalVault)
26Pop
27MoveLoc[2](Arg2: &Position)
28Pop
29MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
30Pop
31MoveLoc[5](Arg5: &Clock)
32Pop
33LdConst[25](u64: 19)
34Abort
B6:
35CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
36MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
37CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
38ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
39ReadRef
40MoveLoc[5](Arg5: &Clock)
41Call clock::timestamp_ms(&Clock): u64
42LdU64(1000)
43Div
44Call rewarder::settle(&mut RewarderManager, u128, u64)
45CopyLoc[2](Arg2: &Position)
46Call object::id<Position>(&Position): ID
47StLoc[16](loc10: ID)
48CopyLoc[2](Arg2: &Position)
49Call position::liquidity(&Position): u128
50StLoc[17](loc11: u128)
51CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
52ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
53Call rewarder::rewarder_index<Ty2>(&RewarderManager): Option<u64>
54StLoc[15](loc9: Option<u64>)
55ImmBorrowLoc[15](loc9: Option<u64>)
56Call option::is_some<u64>(&Option<u64>): bool
57BrFalse(59)
B7:
58Branch(67)
B8:
59MoveLoc[3](Arg3: &mut RewarderGlobalVault)
60Pop
61MoveLoc[2](Arg2: &Position)
62Pop
63MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
64Pop
65LdConst[23](u64: 17)
66Abort
B9:
67MutBorrowLoc[15](loc9: Option<u64>)
68Call option::extract<u64>(&mut Option<u64>): u64
69StLoc[19](loc13: u64)
70CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
71ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
72CopyLoc[16](loc10: ID)
73Call position::inited_rewards_count(&PositionManager, ID): u64
74StLoc[14](loc8: u64)
75MoveLoc[4](Arg4: bool)
76BrFalse(82)
B10:
77MoveLoc[17](loc11: u128)
78LdU128(0)
79Neq
80StLoc[7](loc1: bool)
81Branch(84)
B11:
82LdFalse
83StLoc[7](loc1: bool)
B12:
84MoveLoc[7](loc1: bool)
85BrFalse(89)
B13:
86LdTrue
87StLoc[6](loc0: bool)
88Branch(93)
B14:
89MoveLoc[14](loc8: u64)
90CopyLoc[19](loc13: u64)
91Le
92StLoc[6](loc0: bool)
B15:
93MoveLoc[6](loc0: bool)
94BrFalse(113)
B16:
95MoveLoc[2](Arg2: &Position)
96Call position::tick_range(&Position): I32 * I32
97StLoc[22](loc16: I32)
98StLoc[21](loc15: I32)
99CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
100FreezeRef
101MoveLoc[21](loc15: I32)
102MoveLoc[22](loc16: I32)
103Call get_rewards_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): vector<u128>
104StLoc[20](loc14: vector<u128>)
105CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
106MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
107CopyLoc[16](loc10: ID)
108MoveLoc[20](loc14: vector<u128>)
109MoveLoc[19](loc13: u64)
110Call position::update_and_reset_rewards(&mut PositionManager, ID, vector<u128>, u64): u64
111StLoc[8](loc2: u64)
112Branch(121)
B17:
113MoveLoc[2](Arg2: &Position)
114Pop
115CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
116MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
117CopyLoc[16](loc10: ID)
118MoveLoc[19](loc13: u64)
119Call position::reset_rewarder(&mut PositionManager, ID, u64): u64
120StLoc[8](loc2: u64)
B18:
121MoveLoc[8](loc2: u64)
122StLoc[18](loc12: u64)
123MoveLoc[3](Arg3: &mut RewarderGlobalVault)
124CopyLoc[18](loc12: u64)
125Call rewarder::withdraw_reward<Ty2>(&mut RewarderGlobalVault, u64): Balance<Ty2>
126StLoc[13](loc7: Balance<Ty2>)
127MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
128FreezeRef
129Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
130StLoc[9](loc3: ID)
131MoveLoc[16](loc10: ID)
132StLoc[10](loc4: ID)
133Call type_name::with_defining_ids<Ty2>(): TypeName
134StLoc[11](loc5: TypeName)
135MoveLoc[18](loc12: u64)
136StLoc[12](loc6: u64)
137MoveLoc[10](loc4: ID)
138MoveLoc[9](loc3: ID)
139MoveLoc[11](loc5: TypeName)
140MoveLoc[12](loc6: u64)
141Pack[24](CollectRewardV2Event)
142Call event::emit<CollectRewardV2Event>(CollectRewardV2Event)
143MoveLoc[13](loc7: Balance<Ty2>)
144Ret
}
public calculate_and_update_rewards<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID, Arg3: &Clock): vector<u64> {
L4: loc0: vector<u64>
L5: loc1: &PositionInfo
L6: loc2: vector<u128>
L7: loc3: I32
L8: loc4: I32
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_collect_reward<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9MoveLoc[3](Arg3: &Clock)
10Pop
11LdConst[31](u64: 25)
12Abort
B3:
13CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
14MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
15CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
17ReadRef
18MoveLoc[3](Arg3: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20LdU64(1000)
21Div
22Call rewarder::settle(&mut RewarderManager, u128, u64)
23CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
25CopyLoc[2](Arg2: ID)
26Call position::borrow_position_info(&PositionManager, ID): &PositionInfo
27StLoc[5](loc1: &PositionInfo)
28CopyLoc[5](loc1: &PositionInfo)
29Call position::info_liquidity(&PositionInfo): u128
30LdU128(0)
31Neq
32BrFalse(50)
B4:
33MoveLoc[5](loc1: &PositionInfo)
34Call position::info_tick_range(&PositionInfo): I32 * I32
35StLoc[8](loc4: I32)
36StLoc[7](loc3: I32)
37CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
38FreezeRef
39MoveLoc[7](loc3: I32)
40MoveLoc[8](loc4: I32)
41Call get_rewards_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): vector<u128>
42StLoc[6](loc2: vector<u128>)
43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
44MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
45MoveLoc[2](Arg2: ID)
46MoveLoc[6](loc2: vector<u128>)
47Call position::update_rewards(&mut PositionManager, ID, vector<u128>): vector<u64>
48StLoc[4](loc0: vector<u64>)
49Branch(57)
B5:
50MoveLoc[5](loc1: &PositionInfo)
51Pop
52MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
53ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
54MoveLoc[2](Arg2: ID)
55Call position::rewards_amount_owned(&PositionManager, ID): vector<u64>
56StLoc[4](loc0: vector<u64>)
B6:
57MoveLoc[4](loc0: vector<u64>)
58Ret
}
public calculate_and_update_reward<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID, Arg3: &Clock): u64 {
L4: loc0: Option<u64>
L5: loc1: vector<u64>
B0:
0CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
2Call rewarder::rewarder_index<Ty2>(&RewarderManager): Option<u64>
3StLoc[4](loc0: Option<u64>)
4ImmBorrowLoc[4](loc0: Option<u64>)
5Call option::is_some<u64>(&Option<u64>): bool
6BrFalse(8)
B1:
7Branch(16)
B2:
8MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
9Pop
10MoveLoc[0](Arg0: &GlobalConfig)
11Pop
12MoveLoc[3](Arg3: &Clock)
13Pop
14LdConst[23](u64: 17)
15Abort
B3:
16MoveLoc[0](Arg0: &GlobalConfig)
17MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
18MoveLoc[2](Arg2: ID)
19MoveLoc[3](Arg3: &Clock)
20Call calculate_and_update_rewards<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, ID, &Clock): vector<u64>
21StLoc[5](loc1: vector<u64>)
22ImmBorrowLoc[5](loc1: vector<u64>)
23MutBorrowLoc[4](loc0: Option<u64>)
24Call option::extract<u64>(&mut Option<u64>): u64
25VecImmBorrow(22)
26ReadRef
27Ret
}
public calculate_and_update_points<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID, Arg3: &Clock): u128 {
L4: loc0: u128
L5: loc1: u128
L6: loc2: &PositionInfo
L7: loc3: I32
L8: loc4: I32
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_collect_reward<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9MoveLoc[3](Arg3: &Clock)
10Pop
11LdConst[31](u64: 25)
12Abort
B3:
13CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
14MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
15CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
17ReadRef
18MoveLoc[3](Arg3: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20LdU64(1000)
21Div
22Call rewarder::settle(&mut RewarderManager, u128, u64)
23CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
25CopyLoc[2](Arg2: ID)
26Call position::borrow_position_info(&PositionManager, ID): &PositionInfo
27StLoc[6](loc2: &PositionInfo)
28CopyLoc[6](loc2: &PositionInfo)
29Call position::info_liquidity(&PositionInfo): u128
30LdU128(0)
31Neq
32BrFalse(50)
B4:
33MoveLoc[6](loc2: &PositionInfo)
34Call position::info_tick_range(&PositionInfo): I32 * I32
35StLoc[8](loc4: I32)
36StLoc[7](loc3: I32)
37CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
38FreezeRef
39MoveLoc[7](loc3: I32)
40MoveLoc[8](loc4: I32)
41Call get_points_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128
42StLoc[5](loc1: u128)
43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
44MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
45MoveLoc[2](Arg2: ID)
46MoveLoc[5](loc1: u128)
47Call position::update_points(&mut PositionManager, ID, u128): u128
48StLoc[4](loc0: u128)
49Branch(55)
B5:
50MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
51Pop
52MoveLoc[6](loc2: &PositionInfo)
53Call position::info_points_owned(&PositionInfo): u128
54StLoc[4](loc0: u128)
B6:
55MoveLoc[4](loc0: u128)
56Ret
}
public calculate_and_update_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID): u64 * u64 {
L3: loc0: u64
L4: loc1: u64
L5: loc2: u128
L6: loc3: u128
L7: loc4: &PositionInfo
L8: loc5: I32
L9: loc6: I32
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_collect_fee<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9LdConst[31](u64: 25)
10Abort
B3:
11CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
12ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
13CopyLoc[2](Arg2: ID)
14Call position::borrow_position_info(&PositionManager, ID): &PositionInfo
15StLoc[7](loc4: &PositionInfo)
16CopyLoc[7](loc4: &PositionInfo)
17Call position::info_liquidity(&PositionInfo): u128
18LdU128(0)
19Neq
20BrFalse(41)
B4:
21MoveLoc[7](loc4: &PositionInfo)
22Call position::info_tick_range(&PositionInfo): I32 * I32
23StLoc[9](loc6: I32)
24StLoc[8](loc5: I32)
25CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
26FreezeRef
27MoveLoc[8](loc5: I32)
28MoveLoc[9](loc6: I32)
29Call get_fee_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128
30StLoc[6](loc3: u128)
31StLoc[5](loc2: u128)
32MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
33MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
34MoveLoc[2](Arg2: ID)
35MoveLoc[5](loc2: u128)
36MoveLoc[6](loc3: u128)
37Call position::update_fee(&mut PositionManager, ID, u128, u128): u64 * u64
38StLoc[4](loc1: u64)
39StLoc[3](loc0: u64)
40Branch(47)
B5:
41MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
42Pop
43MoveLoc[7](loc4: &PositionInfo)
44Call position::info_fee_owned(&PositionInfo): u64 * u64
45StLoc[4](loc1: u64)
46StLoc[3](loc0: u64)
B6:
47MoveLoc[3](loc0: u64)
48MoveLoc[4](loc1: u64)
49Ret
}
public get_position_amounts<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: ID): u64 * u64 {
B0:
0LdConst[38](u64: 32)
1Abort
}
public get_position_amounts_v2<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u64 * u64 {
L2: loc0: u128
L3: loc1: &PositionInfo
L4: loc2: I32
L5: loc3: I32
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2MoveLoc[1](Arg1: ID)
3Call position::borrow_position_info(&PositionManager, ID): &PositionInfo
4StLoc[3](loc1: &PositionInfo)
5CopyLoc[3](loc1: &PositionInfo)
6Call position::info_tick_range(&PositionInfo): I32 * I32
7StLoc[5](loc3: I32)
8StLoc[4](loc2: I32)
9MoveLoc[3](loc1: &PositionInfo)
10Call position::info_liquidity(&PositionInfo): u128
11StLoc[2](loc0: u128)
12MoveLoc[4](loc2: I32)
13MoveLoc[5](loc3: I32)
14CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
15ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
16ReadRef
17MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
18ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
19ReadRef
20MoveLoc[2](loc0: u128)
21LdFalse
22Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64
23Ret
}
public flash_swap<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: bool, Arg3: bool, Arg4: u64, Arg5: u128, Arg6: &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_swap<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9MoveLoc[0](Arg0: &GlobalConfig)
10Pop
11MoveLoc[6](Arg6: &Clock)
12Pop
13LdConst[31](u64: 25)
14Abort
B3:
15MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16MoveLoc[0](Arg0: &GlobalConfig)
17LdConst[51](address: 0x00..)
18Call object::id_from_address(address): ID
19LdU64(0)
20MoveLoc[2](Arg2: bool)
21MoveLoc[3](Arg3: bool)
22MoveLoc[4](Arg4: u64)
23MoveLoc[5](Arg5: u128)
24MoveLoc[6](Arg6: &Clock)
25Call flash_swap_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &GlobalConfig, ID, u64, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
26Ret
}
public repay_flash_swap<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: Balance<Ty1>, Arg4: FlashSwapReceipt<Ty0, Ty1>) {
L5: loc0: bool
L6: loc1: u64
L7: loc2: ID
L8: loc3: u64
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[4](Arg4: FlashSwapReceipt<Ty0, Ty1>)
3UnpackGeneric[2](FlashSwapReceipt<Ty0, Ty1>)
4StLoc[8](loc3: u64)
5StLoc[6](loc1: u64)
6Pop
7StLoc[5](loc0: bool)
8StLoc[7](loc2: ID)
9CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10FreezeRef
11Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
12MoveLoc[7](loc2: ID)
13Eq
14BrFalse(16)
B1:
15Branch(20)
B2:
16MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
17Pop
18LdConst[20](u64: 14)
19Abort
B3:
20MoveLoc[8](loc3: u64)
21LdU64(0)
22Eq
23BrFalse(25)
B4:
24Branch(29)
B5:
25MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
26Pop
27LdConst[20](u64: 14)
28Abort
B6:
29MoveLoc[5](loc0: bool)
30BrFalse(49)
B7:
31ImmBorrowLoc[2](Arg2: Balance<Ty0>)
32Call balance::value<Ty0>(&Balance<Ty0>): u64
33MoveLoc[6](loc1: u64)
34Eq
35BrFalse(37)
B8:
36Branch(41)
B9:
37MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
38Pop
39LdConst[6](u64: 0)
40Abort
B10:
41MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
42MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
43MoveLoc[2](Arg2: Balance<Ty0>)
44Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
45Pop
46MoveLoc[3](Arg3: Balance<Ty1>)
47Call balance::destroy_zero<Ty1>(Balance<Ty1>)
48Branch(66)
B11:
49ImmBorrowLoc[3](Arg3: Balance<Ty1>)
50Call balance::value<Ty1>(&Balance<Ty1>): u64
51MoveLoc[6](loc1: u64)
52Eq
53BrFalse(55)
B12:
54Branch(59)
B13:
55MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
56Pop
57LdConst[6](u64: 0)
58Abort
B14:
59MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
60MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
61MoveLoc[3](Arg3: Balance<Ty1>)
62Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
63Pop
64MoveLoc[2](Arg2: Balance<Ty0>)
65Call balance::destroy_zero<Ty0>(Balance<Ty0>)
B15:
66Ret
}
public flash_swap_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Partner, Arg3: bool, Arg4: bool, Arg5: u64, Arg6: u128, Arg7: &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {
L8: loc0: u64
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_swap<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(17)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9MoveLoc[2](Arg2: &Partner)
10Pop
11MoveLoc[0](Arg0: &GlobalConfig)
12Pop
13MoveLoc[7](Arg7: &Clock)
14Pop
15LdConst[31](u64: 25)
16Abort
B3:
17CopyLoc[2](Arg2: &Partner)
18CopyLoc[7](Arg7: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20LdU64(1000)
21Div
22Call partner::current_ref_fee_rate(&Partner, u64): u64
23StLoc[8](loc0: u64)
24MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
25MoveLoc[0](Arg0: &GlobalConfig)
26MoveLoc[2](Arg2: &Partner)
27Call object::id<Partner>(&Partner): ID
28MoveLoc[8](loc0: u64)
29MoveLoc[3](Arg3: bool)
30MoveLoc[4](Arg4: bool)
31MoveLoc[5](Arg5: u64)
32MoveLoc[6](Arg6: u128)
33MoveLoc[7](Arg7: &Clock)
34Call flash_swap_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &GlobalConfig, ID, u64, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
35Ret
}
public repay_flash_swap_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Partner, Arg3: Balance<Ty0>, Arg4: Balance<Ty1>, Arg5: FlashSwapReceipt<Ty0, Ty1>) {
L6: loc0: bool
L7: loc1: ID
L8: loc2: u64
L9: loc3: ID
L10: loc4: Balance<Ty0>
L11: loc5: Balance<Ty1>
L12: loc6: u64
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[5](Arg5: FlashSwapReceipt<Ty0, Ty1>)
3UnpackGeneric[2](FlashSwapReceipt<Ty0, Ty1>)
4StLoc[12](loc6: u64)
5StLoc[8](loc2: u64)
6StLoc[7](loc1: ID)
7StLoc[6](loc0: bool)
8StLoc[9](loc3: ID)
9CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10FreezeRef
11Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
12MoveLoc[9](loc3: ID)
13Eq
14BrFalse(16)
B1:
15Branch(22)
B2:
16MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
17Pop
18MoveLoc[2](Arg2: &mut Partner)
19Pop
20LdConst[20](u64: 14)
21Abort
B3:
22CopyLoc[2](Arg2: &mut Partner)
23FreezeRef
24Call object::id<Partner>(&Partner): ID
25MoveLoc[7](loc1: ID)
26Eq
27BrFalse(29)
B4:
28Branch(35)
B5:
29MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
30Pop
31MoveLoc[2](Arg2: &mut Partner)
32Pop
33LdConst[20](u64: 14)
34Abort
B6:
35MoveLoc[6](loc0: bool)
36BrFalse(71)
B7:
37ImmBorrowLoc[3](Arg3: Balance<Ty0>)
38Call balance::value<Ty0>(&Balance<Ty0>): u64
39MoveLoc[8](loc2: u64)
40Eq
41BrFalse(43)
B8:
42Branch(49)
B9:
43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
44Pop
45MoveLoc[2](Arg2: &mut Partner)
46Pop
47LdConst[6](u64: 0)
48Abort
B10:
49CopyLoc[12](loc6: u64)
50LdU64(0)
51Gt
52BrFalse(61)
B11:
53MutBorrowLoc[3](Arg3: Balance<Ty0>)
54MoveLoc[12](loc6: u64)
55Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
56StLoc[10](loc4: Balance<Ty0>)
57MoveLoc[2](Arg2: &mut Partner)
58MoveLoc[10](loc4: Balance<Ty0>)
59Call partner::receive_ref_fee_internal<Ty0>(&mut Partner, Balance<Ty0>)
60Branch(63)
B12:
61MoveLoc[2](Arg2: &mut Partner)
62Pop
B13:
63MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
64MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
65MoveLoc[3](Arg3: Balance<Ty0>)
66Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
67Pop
68MoveLoc[4](Arg4: Balance<Ty1>)
69Call balance::destroy_zero<Ty1>(Balance<Ty1>)
70Branch(104)
B14:
71ImmBorrowLoc[4](Arg4: Balance<Ty1>)
72Call balance::value<Ty1>(&Balance<Ty1>): u64
73MoveLoc[8](loc2: u64)
74Eq
75BrFalse(77)
B15:
76Branch(83)
B16:
77MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
78Pop
79MoveLoc[2](Arg2: &mut Partner)
80Pop
81LdConst[6](u64: 0)
82Abort
B17:
83CopyLoc[12](loc6: u64)
84LdU64(0)
85Gt
86BrFalse(95)
B18:
87MutBorrowLoc[4](Arg4: Balance<Ty1>)
88MoveLoc[12](loc6: u64)
89Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
90StLoc[11](loc5: Balance<Ty1>)
91MoveLoc[2](Arg2: &mut Partner)
92MoveLoc[11](loc5: Balance<Ty1>)
93Call partner::receive_ref_fee_internal<Ty1>(&mut Partner, Balance<Ty1>)
94Branch(97)
B19:
95MoveLoc[2](Arg2: &mut Partner)
96Pop
B20:
97MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
98MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
99MoveLoc[4](Arg4: Balance<Ty1>)
100Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
101Pop
102MoveLoc[3](Arg3: Balance<Ty0>)
103Call balance::destroy_zero<Ty0>(Balance<Ty0>)
B21:
104Ret
}
public collect_protocol_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &TxContext): Balance<Ty0> * Balance<Ty1> {
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3MoveLoc[2](Arg2: &TxContext)
4Call tx_context::sender(&TxContext): address
5Call config::check_protocol_fee_claim_role(&GlobalConfig, address)
6MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
7Call collect_protocol_fee_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): Balance<Ty0> * Balance<Ty1>
8Ret
}
public collect_protocol_fee_with_cap<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GlobalConfig, Arg2: &ProtocolFeeCollectCap): Balance<Ty0> * Balance<Ty1> {
L3: loc0: address
B0:
0CopyLoc[1](Arg1: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[2](Arg2: &ProtocolFeeCollectCap)
3Call object::id_address<ProtocolFeeCollectCap>(&ProtocolFeeCollectCap): address
4StLoc[3](loc0: address)
5MoveLoc[1](Arg1: &GlobalConfig)
6MoveLoc[3](loc0: address)
7Call config::check_protocol_fee_claim_role(&GlobalConfig, address)
8MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
9Call collect_protocol_fee_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): Balance<Ty0> * Balance<Ty1>
10Ret
}
public initialize_rewarder<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &TxContext) {
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3MoveLoc[2](Arg2: &TxContext)
4Call tx_context::sender(&TxContext): address
5Call config::check_rewarder_manager_role(&GlobalConfig, address)
6CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
7MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
8Call rewarder::add_rewarder<Ty2>(&mut RewarderManager)
9MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10FreezeRef
11Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
12Call type_name::with_defining_ids<Ty2>(): TypeName
13Pack[22](AddRewarderEvent)
14Call event::emit<AddRewarderEvent>(AddRewarderEvent)
15Ret
}
public update_emission<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &RewarderGlobalVault, Arg3: u128, Arg4: &Clock, Arg5: &TxContext) {
L6: loc0: u128
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3MoveLoc[5](Arg5: &TxContext)
4Call tx_context::sender(&TxContext): address
5Call config::check_rewarder_manager_role(&GlobalConfig, address)
6CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
8ReadRef
9StLoc[6](loc0: u128)
10MoveLoc[2](Arg2: &RewarderGlobalVault)
11CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
12MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
13MoveLoc[6](loc0: u128)
14CopyLoc[3](Arg3: u128)
15MoveLoc[4](Arg4: &Clock)
16Call clock::timestamp_ms(&Clock): u64
17LdU64(1000)
18Div
19Call rewarder::update_emission<Ty2>(&RewarderGlobalVault, &mut RewarderManager, u128, u128, u64)
20MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
21FreezeRef
22Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
23Call type_name::with_defining_ids<Ty2>(): TypeName
24MoveLoc[3](Arg3: u128)
25Pack[21](UpdateEmissionEvent)
26Call event::emit<UpdateEmissionEvent>(UpdateEmissionEvent)
27Ret
}
public update_position_url<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: String, Arg3: &TxContext) {
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3MoveLoc[3](Arg3: &TxContext)
4Call tx_context::sender(&TxContext): address
5Call config::check_pool_manager_role(&GlobalConfig, address)
6MoveLoc[2](Arg2: String)
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8MutBorrowFieldGeneric[2](Pool.url: String)
9WriteRef
10Ret
}
public update_fee_rate<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: &TxContext) {
L4: loc0: u64
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[2](Arg2: u64)
3Call config::max_fee_rate(): u64
4Gt
5BrFalse(14)
B1:
6MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
7Pop
8MoveLoc[3](Arg3: &TxContext)
9Pop
10MoveLoc[0](Arg0: &GlobalConfig)
11Pop
12LdConst[15](u64: 9)
13Abort
B2:
14MoveLoc[0](Arg0: &GlobalConfig)
15MoveLoc[3](Arg3: &TxContext)
16Call tx_context::sender(&TxContext): address
17Call config::check_pool_manager_role(&GlobalConfig, address)
18CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
19ImmBorrowFieldGeneric[15](Pool.fee_rate: u64)
20ReadRef
21StLoc[4](loc0: u64)
22CopyLoc[2](Arg2: u64)
23CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24MutBorrowFieldGeneric[15](Pool.fee_rate: u64)
25WriteRef
26MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
27FreezeRef
28Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
29MoveLoc[4](loc0: u64)
30MoveLoc[2](Arg2: u64)
31Pack[20](UpdateFeeRateEvent)
32Call event::emit<UpdateFeeRateEvent>(UpdateFeeRateEvent)
33Ret
}
public update_pool<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Coin<Ty0>, Arg3: Coin<Ty1>, Arg4: &TxContext) {
B0:
0LdU64(0)
1Abort
}
public pause<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &TxContext) {
B0:
0LdConst[38](u64: 32)
1Abort
}
public unpause<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &TxContext) {
B0:
0LdConst[38](u64: 32)
1Abort
}
public flash_loan<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: bool, Arg3: u64): Balance<Ty0> * Balance<Ty1> * FlashLoanReceipt {
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_flash_loan<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9MoveLoc[0](Arg0: &GlobalConfig)
10Pop
11LdConst[31](u64: 25)
12Abort
B3:
13MoveLoc[0](Arg0: &GlobalConfig)
14MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
15LdConst[51](address: 0x00..)
16Call object::id_from_address(address): ID
17LdU64(0)
18MoveLoc[2](Arg2: bool)
19MoveLoc[3](Arg3: u64)
20Call flash_loan_internal<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, ID, u64, bool, u64): Balance<Ty0> * Balance<Ty1> * FlashLoanReceipt
21Ret
}
public flash_loan_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Partner, Arg3: bool, Arg4: u64, Arg5: &Clock): Balance<Ty0> * Balance<Ty1> * FlashLoanReceipt {
L6: loc0: u64
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call is_allow_flash_loan<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
5BrFalse(7)
B1:
6Branch(17)
B2:
7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8Pop
9MoveLoc[2](Arg2: &Partner)
10Pop
11MoveLoc[0](Arg0: &GlobalConfig)
12Pop
13MoveLoc[5](Arg5: &Clock)
14Pop
15LdConst[31](u64: 25)
16Abort
B3:
17CopyLoc[2](Arg2: &Partner)
18MoveLoc[5](Arg5: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20LdU64(1000)
21Div
22Call partner::current_ref_fee_rate(&Partner, u64): u64
23StLoc[6](loc0: u64)
24MoveLoc[0](Arg0: &GlobalConfig)
25MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
26MoveLoc[2](Arg2: &Partner)
27Call object::id<Partner>(&Partner): ID
28MoveLoc[6](loc0: u64)
29MoveLoc[3](Arg3: bool)
30MoveLoc[4](Arg4: u64)
31Call flash_loan_internal<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, ID, u64, bool, u64): Balance<Ty0> * Balance<Ty1> * FlashLoanReceipt
32Ret
}
public repay_flash_loan<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: Balance<Ty1>, Arg4: FlashLoanReceipt) {
L5: loc0: u64
L6: loc1: u64
L7: loc2: bool
L8: loc3: u64
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[4](Arg4: FlashLoanReceipt)
3Unpack[8](FlashLoanReceipt)
4StLoc[8](loc3: u64)
5StLoc[6](loc1: u64)
6StLoc[5](loc0: u64)
7Pop
8StLoc[7](loc2: bool)
9CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10FreezeRef
11Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
12Eq
13BrFalse(15)
B1:
14Branch(19)
B2:
15MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16Pop
17LdConst[26](u64: 20)
18Abort
B3:
19MoveLoc[8](loc3: u64)
20LdU64(0)
21Eq
22BrFalse(24)
B4:
23Branch(28)
B5:
24MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
25Pop
26LdConst[26](u64: 20)
27Abort
B6:
28MoveLoc[7](loc2: bool)
29BrFalse(50)
B7:
30ImmBorrowLoc[2](Arg2: Balance<Ty0>)
31Call balance::value<Ty0>(&Balance<Ty0>): u64
32MoveLoc[5](loc0: u64)
33MoveLoc[6](loc1: u64)
34Add
35Eq
36BrFalse(38)
B8:
37Branch(42)
B9:
38MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
39Pop
40LdConst[6](u64: 0)
41Abort
B10:
42MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
43MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
44MoveLoc[2](Arg2: Balance<Ty0>)
45Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
46Pop
47MoveLoc[3](Arg3: Balance<Ty1>)
48Call balance::destroy_zero<Ty1>(Balance<Ty1>)
49Branch(69)
B11:
50ImmBorrowLoc[3](Arg3: Balance<Ty1>)
51Call balance::value<Ty1>(&Balance<Ty1>): u64
52MoveLoc[5](loc0: u64)
53MoveLoc[6](loc1: u64)
54Add
55Eq
56BrFalse(58)
B12:
57Branch(62)
B13:
58MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
59Pop
60LdConst[6](u64: 0)
61Abort
B14:
62MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
63MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
64MoveLoc[3](Arg3: Balance<Ty1>)
65Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
66Pop
67MoveLoc[2](Arg2: Balance<Ty0>)
68Call balance::destroy_zero<Ty0>(Balance<Ty0>)
B15:
69Ret
}
public repay_flash_loan_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Partner, Arg3: Balance<Ty0>, Arg4: Balance<Ty1>, Arg5: FlashLoanReceipt) {
L6: loc0: u64
L7: loc1: u64
L8: loc2: bool
L9: loc3: ID
L10: loc4: Balance<Ty0>
L11: loc5: Balance<Ty1>
L12: loc6: u64
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[5](Arg5: FlashLoanReceipt)
3Unpack[8](FlashLoanReceipt)
4StLoc[12](loc6: u64)
5StLoc[7](loc1: u64)
6StLoc[6](loc0: u64)
7StLoc[9](loc3: ID)
8StLoc[8](loc2: bool)
9CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10FreezeRef
11Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
12Eq
13BrFalse(15)
B1:
14Branch(21)
B2:
15MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16Pop
17MoveLoc[2](Arg2: &mut Partner)
18Pop
19LdConst[26](u64: 20)
20Abort
B3:
21MoveLoc[9](loc3: ID)
22CopyLoc[2](Arg2: &mut Partner)
23FreezeRef
24Call object::id<Partner>(&Partner): ID
25Eq
26BrFalse(28)
B4:
27Branch(34)
B5:
28MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
29Pop
30MoveLoc[2](Arg2: &mut Partner)
31Pop
32LdConst[26](u64: 20)
33Abort
B6:
34MoveLoc[8](loc2: bool)
35BrFalse(72)
B7:
36ImmBorrowLoc[3](Arg3: Balance<Ty0>)
37Call balance::value<Ty0>(&Balance<Ty0>): u64
38MoveLoc[6](loc0: u64)
39MoveLoc[7](loc1: u64)
40Add
41Eq
42BrFalse(44)
B8:
43Branch(50)
B9:
44MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
45Pop
46MoveLoc[2](Arg2: &mut Partner)
47Pop
48LdConst[6](u64: 0)
49Abort
B10:
50CopyLoc[12](loc6: u64)
51LdU64(0)
52Gt
53BrFalse(62)
B11:
54MutBorrowLoc[3](Arg3: Balance<Ty0>)
55MoveLoc[12](loc6: u64)
56Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
57StLoc[10](loc4: Balance<Ty0>)
58MoveLoc[2](Arg2: &mut Partner)
59MoveLoc[10](loc4: Balance<Ty0>)
60Call partner::receive_ref_fee_internal<Ty0>(&mut Partner, Balance<Ty0>)
61Branch(64)
B12:
62MoveLoc[2](Arg2: &mut Partner)
63Pop
B13:
64MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
65MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
66MoveLoc[3](Arg3: Balance<Ty0>)
67Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
68Pop
69MoveLoc[4](Arg4: Balance<Ty1>)
70Call balance::destroy_zero<Ty1>(Balance<Ty1>)
71Branch(107)
B14:
72ImmBorrowLoc[4](Arg4: Balance<Ty1>)
73Call balance::value<Ty1>(&Balance<Ty1>): u64
74MoveLoc[6](loc0: u64)
75MoveLoc[7](loc1: u64)
76Add
77Eq
78BrFalse(80)
B15:
79Branch(86)
B16:
80MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
81Pop
82MoveLoc[2](Arg2: &mut Partner)
83Pop
84LdConst[6](u64: 0)
85Abort
B17:
86CopyLoc[12](loc6: u64)
87LdU64(0)
88Gt
89BrFalse(98)
B18:
90MutBorrowLoc[4](Arg4: Balance<Ty1>)
91MoveLoc[12](loc6: u64)
92Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
93StLoc[11](loc5: Balance<Ty1>)
94MoveLoc[2](Arg2: &mut Partner)
95MoveLoc[11](loc5: Balance<Ty1>)
96Call partner::receive_ref_fee_internal<Ty1>(&mut Partner, Balance<Ty1>)
97Branch(100)
B19:
98MoveLoc[2](Arg2: &mut Partner)
99Pop
B20:
100MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
101MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
102MoveLoc[4](Arg4: Balance<Ty1>)
103Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
104Pop
105MoveLoc[3](Arg3: Balance<Ty0>)
106Call balance::destroy_zero<Ty0>(Balance<Ty0>)
B21:
107Ret
}
entry public init_position_snapshot<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: &mut TxContext) {
L4: loc0: PositionLiquiditySnapshot
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::check_emergency_restore_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3CopyLoc[3](Arg3: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Call config::check_pool_manager_role(&GlobalConfig, address)
7CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
9ReadRef
10BrFalse(12)
B1:
11Branch(18)
B2:
12MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
13Pop
14MoveLoc[3](Arg3: &mut TxContext)
15Pop
16LdConst[30](u64: 24)
17Abort
B3:
18CopyLoc[2](Arg2: u64)
19LdConst[2](u64: 1000..)
20Le
21BrFalse(23)
B4:
22Branch(29)
B5:
23MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
24Pop
25MoveLoc[3](Arg3: &mut TxContext)
26Pop
27LdConst[33](u64: 27)
28Abort
B6:
29CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
30ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
31ReadRef
32MoveLoc[2](Arg2: u64)
33MoveLoc[3](Arg3: &mut TxContext)
34Call position_snapshot::new(u128, u64, &mut TxContext): PositionLiquiditySnapshot
35StLoc[4](loc0: PositionLiquiditySnapshot)
36MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
37MutBorrowFieldGeneric[14](Pool.id: UID)
38LdConst[3](vector<u8>: "pos..)
39Call string::utf8(vector<u8>): String
40MoveLoc[4](loc0: PositionLiquiditySnapshot)
41Call dynamic_object_field::add<String, PositionLiquiditySnapshot>(&mut UID, String, PositionLiquiditySnapshot)
42Ret
}
public position_liquidity_snapshot<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &PositionLiquiditySnapshot {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[3](vector<u8>: "pos..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
8Pop
9LdConst[37](u64: 31)
10Abort
B3:
11MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
12ImmBorrowFieldGeneric[14](Pool.id: UID)
13LdConst[3](vector<u8>: "pos..)
14Call string::utf8(vector<u8>): String
15Call dynamic_object_field::borrow<String, PositionLiquiditySnapshot>(&UID, String): &PositionLiquiditySnapshot
16Ret
}
public is_attacked_position<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): bool {
L2: loc0: bool
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[3](vector<u8>: "pos..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(15)
B1:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[14](Pool.id: UID)
8LdConst[3](vector<u8>: "pos..)
9Call string::utf8(vector<u8>): String
10Call dynamic_object_field::borrow<String, PositionLiquiditySnapshot>(&UID, String): &PositionLiquiditySnapshot
11MoveLoc[1](Arg1: ID)
12Call position_snapshot::contains(&PositionLiquiditySnapshot, ID): bool
13StLoc[2](loc0: bool)
14Branch(19)
B2:
15MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
16Pop
17LdFalse
18StLoc[2](loc0: bool)
B3:
19MoveLoc[2](loc0: bool)
20Ret
}
public get_position_snapshot_by_position_id<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): PositionSnapshot {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[3](vector<u8>: "pos..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
8Pop
9LdConst[37](u64: 31)
10Abort
B3:
11MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
12ImmBorrowFieldGeneric[14](Pool.id: UID)
13LdConst[3](vector<u8>: "pos..)
14Call string::utf8(vector<u8>): String
15Call dynamic_object_field::borrow<String, PositionLiquiditySnapshot>(&UID, String): &PositionLiquiditySnapshot
16MoveLoc[1](Arg1: ID)
17Call position_snapshot::get(&PositionLiquiditySnapshot, ID): PositionSnapshot
18Ret
}
public apply_liquidity_cut<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {
B0:
0LdConst[38](u64: 32)
1Abort
}
public governance_fund_injection<Ty0, Ty1>(Arg0: &mut GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Coin<Ty0>, Arg3: Coin<Ty1>, Arg4: &mut TxContext) {
B0:
0LdConst[38](u64: 32)
1Abort
}
public governance_fund_withdrawal<Ty0, Ty1>(Arg0: &mut GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: u64, Arg4: &mut TxContext) {
B0:
0LdConst[38](u64: 32)
1Abort
}
public emergency_remove_malicious_position<Ty0, Ty1>(Arg0: &mut GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID, Arg3: &mut TxContext) {
B0:
0LdConst[38](u64: 32)
1Abort
}
public emergency_restore_pool_state<Ty0, Ty1>(Arg0: &mut GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u128, Arg3: u128, Arg4: &Clock, Arg5: &mut TxContext) {
B0:
0LdConst[38](u64: 32)
1Abort
}
public get_amount_by_liquidity(Arg0: I32, Arg1: I32, Arg2: I32, Arg3: u128, Arg4: u128, Arg5: bool): u64 * u64 {
B0:
0MoveLoc[0](Arg0: I32)
1MoveLoc[1](Arg1: I32)
2MoveLoc[2](Arg2: I32)
3MoveLoc[3](Arg3: u128)
4MoveLoc[4](Arg4: u128)
5MoveLoc[5](Arg5: bool)
6Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64
7Ret
}
public get_liquidity_from_amount(Arg0: I32, Arg1: I32, Arg2: I32, Arg3: u128, Arg4: u64, Arg5: bool): u128 * u64 * u64 {
B0:
0MoveLoc[0](Arg0: I32)
1MoveLoc[1](Arg1: I32)
2MoveLoc[2](Arg2: I32)
3MoveLoc[3](Arg3: u128)
4MoveLoc[4](Arg4: u64)
5MoveLoc[5](Arg5: bool)
6Call clmm_math::get_liquidity_by_amount(I32, I32, I32, u128, u64, bool): u128 * u64 * u64
7Ret
}
public get_fee_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): u128 * u128 {
L3: loc0: Option<Tick>
L4: loc1: Option<Tick>
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
2MoveLoc[1](Arg1: I32)
3Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
4StLoc[3](loc0: Option<Tick>)
5CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
6ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
7MoveLoc[2](Arg2: I32)
8Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
9StLoc[4](loc1: Option<Tick>)
10CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
11ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
12ReadRef
13CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
14ImmBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
15ReadRef
16MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
17ImmBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
18ReadRef
19MoveLoc[3](loc0: Option<Tick>)
20MoveLoc[4](loc1: Option<Tick>)
21Call tick::get_fee_in_range(I32, u128, u128, Option<Tick>, Option<Tick>): u128 * u128
22Ret
}
public get_rewards_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): vector<u128> {
L3: loc0: Option<Tick>
L4: loc1: Option<Tick>
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
2MoveLoc[1](Arg1: I32)
3Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
4StLoc[3](loc0: Option<Tick>)
5CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
6ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
7MoveLoc[2](Arg2: I32)
8Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
9StLoc[4](loc1: Option<Tick>)
10CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
11ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
12ReadRef
13MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
14ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
15Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>
16MoveLoc[3](loc0: Option<Tick>)
17MoveLoc[4](loc1: Option<Tick>)
18Call tick::get_rewards_in_range(I32, vector<u128>, Option<Tick>, Option<Tick>): vector<u128>
19Ret
}
public get_points_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): u128 {
L3: loc0: Option<Tick>
L4: loc1: Option<Tick>
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
2MoveLoc[1](Arg1: I32)
3Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
4StLoc[3](loc0: Option<Tick>)
5CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
6ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
7MoveLoc[2](Arg2: I32)
8Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
9StLoc[4](loc1: Option<Tick>)
10CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
11ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
12ReadRef
13MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
14ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
15Call rewarder::points_growth_global(&RewarderManager): u128
16MoveLoc[3](loc0: Option<Tick>)
17MoveLoc[4](loc1: Option<Tick>)
18Call tick::get_points_in_range(I32, u128, Option<Tick>, Option<Tick>): u128
19Ret
}
public get_fee_rewards_points_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): u128 * u128 * vector<u128> * u128 {
L3: loc0: u128
L4: loc1: u128
L5: loc2: Option<Tick>
L6: loc3: Option<Tick>
L7: loc4: u128
L8: loc5: vector<u128>
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
2MoveLoc[1](Arg1: I32)
3Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
4StLoc[5](loc2: Option<Tick>)
5CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
6ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
7MoveLoc[2](Arg2: I32)
8Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>
9StLoc[6](loc3: Option<Tick>)
10CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
11ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
12ReadRef
13CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
14ImmBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
15ReadRef
16CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
17ImmBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
18ReadRef
19CopyLoc[5](loc2: Option<Tick>)
20CopyLoc[6](loc3: Option<Tick>)
21Call tick::get_fee_in_range(I32, u128, u128, Option<Tick>, Option<Tick>): u128 * u128
22StLoc[4](loc1: u128)
23StLoc[3](loc0: u128)
24CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
25ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
26ReadRef
27CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
28ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
29Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>
30CopyLoc[5](loc2: Option<Tick>)
31CopyLoc[6](loc3: Option<Tick>)
32Call tick::get_rewards_in_range(I32, vector<u128>, Option<Tick>, Option<Tick>): vector<u128>
33StLoc[8](loc5: vector<u128>)
34CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
35ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
36ReadRef
37MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
38ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
39Call rewarder::points_growth_global(&RewarderManager): u128
40MoveLoc[5](loc2: Option<Tick>)
41MoveLoc[6](loc3: Option<Tick>)
42Call tick::get_points_in_range(I32, u128, Option<Tick>, Option<Tick>): u128
43StLoc[7](loc4: u128)
44MoveLoc[3](loc0: u128)
45MoveLoc[4](loc1: u128)
46MoveLoc[8](loc5: vector<u128>)
47MoveLoc[7](loc4: u128)
48Ret
}
public fetch_ticks<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: vector<u32>, Arg2: u64): vector<Tick> {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
2MoveLoc[1](Arg1: vector<u32>)
3MoveLoc[2](Arg2: u64)
4Call tick::fetch_ticks(&TickManager, vector<u32>, u64): vector<Tick>
5Ret
}
public fetch_positions<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: vector<ID>, Arg2: u64): vector<PositionInfo> {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2MoveLoc[1](Arg1: vector<ID>)
3MoveLoc[2](Arg2: u64)
4Call position::fetch_positions(&PositionManager, vector<ID>, u64): vector<PositionInfo>
5Ret
}
public calculate_swap_result<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: bool, Arg2: bool, Arg3: u64): CalculatedSwapResult {
L4: loc0: bool
L5: loc1: I128
L6: loc2: u64
L7: loc3: u64
L8: loc4: u128
L9: loc5: u128
L10: loc6: u64
L11: loc7: I128
L12: loc8: u128
L13: loc9: u128
L14: loc10: u128
L15: loc11: OptionU64
L16: loc12: OptionU64
L17: loc13: u64
L18: loc14: CalculatedSwapResult
L19: loc15: SwapResult
L20: loc16: u128
L21: loc17: &Tick
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
2ReadRef
3StLoc[9](loc5: u128)
4CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
5ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
6ReadRef
7StLoc[8](loc4: u128)
8Call default_swap_result(): SwapResult
9StLoc[19](loc15: SwapResult)
10MoveLoc[3](Arg3: u64)
11StLoc[17](loc13: u64)
12CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
13ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
14CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
15ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
16ReadRef
17CopyLoc[1](Arg1: bool)
18Call tick::first_score_for_swap(&TickManager, I32, bool): OptionU64
19StLoc[16](loc12: OptionU64)
20LdU64(0)
21LdU64(0)
22LdU64(0)
23CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
24ImmBorrowFieldGeneric[15](Pool.fee_rate: u64)
25ReadRef
26CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
27ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
28ReadRef
29LdFalse
30VecPack(192, 0)
31Pack[9](CalculatedSwapResult)
32StLoc[18](loc14: CalculatedSwapResult)
B1:
33CopyLoc[17](loc13: u64)
34LdU64(0)
35Gt
36BrFalse(178)
B2:
37Branch(38)
B3:
38ImmBorrowLoc[16](loc12: OptionU64)
39Call option_u64::is_none(&OptionU64): bool
40BrFalse(48)
B4:
41MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
42Pop
43LdTrue
44MutBorrowLoc[18](loc14: CalculatedSwapResult)
45MutBorrowField[17](CalculatedSwapResult.is_exceed: bool)
46WriteRef
47Branch(178)
B5:
48CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
49ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
50ImmBorrowLoc[16](loc12: OptionU64)
51Call option_u64::borrow(&OptionU64): u64
52CopyLoc[1](Arg1: bool)
53Call tick::borrow_tick_for_swap(&TickManager, u64, bool): &Tick * OptionU64
54StLoc[15](loc11: OptionU64)
55StLoc[21](loc17: &Tick)
56MoveLoc[15](loc11: OptionU64)
57StLoc[16](loc12: OptionU64)
58CopyLoc[21](loc17: &Tick)
59Call tick::sqrt_price(&Tick): u128
60StLoc[20](loc16: u128)
61CopyLoc[9](loc5: u128)
62CopyLoc[20](loc16: u128)
63CopyLoc[8](loc4: u128)
64CopyLoc[17](loc13: u64)
65CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
66ImmBorrowFieldGeneric[15](Pool.fee_rate: u64)
67ReadRef
68CopyLoc[1](Arg1: bool)
69CopyLoc[2](Arg2: bool)
70Call clmm_math::compute_swap_step(u128, u128, u128, u64, u64, bool, bool): u64 * u64 * u128 * u64
71StLoc[10](loc6: u64)
72StLoc[14](loc10: u128)
73StLoc[7](loc3: u64)
74StLoc[6](loc2: u64)
75CopyLoc[6](loc2: u64)
76LdU64(0)
77Neq
78BrFalse(82)
B6:
79LdTrue
80StLoc[4](loc0: bool)
81Branch(86)
B7:
82CopyLoc[10](loc6: u64)
83LdU64(0)
84Neq
85StLoc[4](loc0: bool)
B8:
86MoveLoc[4](loc0: bool)
87BrFalse(106)
B9:
88CopyLoc[2](Arg2: bool)
89BrFalse(97)
B10:
90MoveLoc[17](loc13: u64)
91CopyLoc[6](loc2: u64)
92Call check_remainer_amount_sub(u64, u64): u64
93CopyLoc[10](loc6: u64)
94Call check_remainer_amount_sub(u64, u64): u64
95StLoc[17](loc13: u64)
96Branch(101)
B11:
97MoveLoc[17](loc13: u64)
98CopyLoc[7](loc3: u64)
99Call check_remainer_amount_sub(u64, u64): u64
100StLoc[17](loc13: u64)
B12:
101MutBorrowLoc[19](loc15: SwapResult)
102CopyLoc[6](loc2: u64)
103CopyLoc[7](loc3: u64)
104CopyLoc[10](loc6: u64)
105Call update_swap_result(&mut SwapResult, u64, u64, u64)
B13:
106MutBorrowLoc[18](loc14: CalculatedSwapResult)
107MutBorrowField[18](CalculatedSwapResult.step_results: vector<SwapStepResult>)
108MoveLoc[9](loc5: u128)
109CopyLoc[20](loc16: u128)
110CopyLoc[8](loc4: u128)
111MoveLoc[6](loc2: u64)
112MoveLoc[7](loc3: u64)
113MoveLoc[10](loc6: u64)
114CopyLoc[17](loc13: u64)
115Pack[10](SwapStepResult)
116VecPushBack(192)
117CopyLoc[14](loc10: u128)
118CopyLoc[20](loc16: u128)
119Eq
120BrFalse(173)
B14:
121MoveLoc[20](loc16: u128)
122StLoc[9](loc5: u128)
123CopyLoc[1](Arg1: bool)
124BrFalse(130)
B15:
125MoveLoc[21](loc17: &Tick)
126Call tick::liquidity_net(&Tick): I128
127Call i128::neg(I128): I128
128StLoc[5](loc1: I128)
129Branch(133)
B16:
130MoveLoc[21](loc17: &Tick)
131Call tick::liquidity_net(&Tick): I128
132StLoc[5](loc1: I128)
B17:
133MoveLoc[5](loc1: I128)
134StLoc[11](loc7: I128)
135CopyLoc[11](loc7: I128)
136Call i128::is_neg(I128): bool
137Not
138BrFalse(156)
B18:
139MoveLoc[11](loc7: I128)
140Call i128::abs_u128(I128): u128
141StLoc[12](loc8: u128)
142CopyLoc[8](loc4: u128)
143CopyLoc[12](loc8: u128)
144Call math_u128::add_check(u128, u128): bool
145BrFalse(147)
B19:
146Branch(151)
B20:
147MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
148Pop
149LdConst[7](u64: 1)
150Abort
B21:
151MoveLoc[8](loc4: u128)
152MoveLoc[12](loc8: u128)
153Add
154StLoc[8](loc4: u128)
155Branch(33)
B22:
156MoveLoc[11](loc7: I128)
157Call i128::abs_u128(I128): u128
158StLoc[13](loc9: u128)
159CopyLoc[8](loc4: u128)
160CopyLoc[13](loc9: u128)
161Ge
162BrFalse(164)
B23:
163Branch(168)
B24:
164MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
165Pop
166LdConst[7](u64: 1)
167Abort
B25:
168MoveLoc[8](loc4: u128)
169MoveLoc[13](loc9: u128)
170Sub
171StLoc[8](loc4: u128)
172Branch(33)
B26:
173MoveLoc[21](loc17: &Tick)
174Pop
175MoveLoc[14](loc10: u128)
176StLoc[9](loc5: u128)
177Branch(33)
B27:
178ImmBorrowLoc[19](loc15: SwapResult)
179ImmBorrowField[19](SwapResult.amount_in: u64)
180ReadRef
181MutBorrowLoc[18](loc14: CalculatedSwapResult)
182MutBorrowField[20](CalculatedSwapResult.amount_in: u64)
183WriteRef
184ImmBorrowLoc[19](loc15: SwapResult)
185ImmBorrowField[21](SwapResult.amount_out: u64)
186ReadRef
187MutBorrowLoc[18](loc14: CalculatedSwapResult)
188MutBorrowField[22](CalculatedSwapResult.amount_out: u64)
189WriteRef
190ImmBorrowLoc[19](loc15: SwapResult)
191ImmBorrowField[23](SwapResult.fee_amount: u64)
192ReadRef
193MutBorrowLoc[18](loc14: CalculatedSwapResult)
194MutBorrowField[24](CalculatedSwapResult.fee_amount: u64)
195WriteRef
196MoveLoc[9](loc5: u128)
197MutBorrowLoc[18](loc14: CalculatedSwapResult)
198MutBorrowField[25](CalculatedSwapResult.after_sqrt_price: u128)
199WriteRef
200MoveLoc[18](loc14: CalculatedSwapResult)
201Ret
}
public balances<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &Balance<Ty0> * &Balance<Ty1> {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
2MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
3ImmBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
4Ret
}
public tick_spacing<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u32 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[17](Pool.tick_spacing: u32)
2ReadRef
3Ret
}
public fee_rate<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[15](Pool.fee_rate: u64)
2ReadRef
3Ret
}
public liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
2ReadRef
3Ret
}
public current_sqrt_price<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
2ReadRef
3Ret
}
public current_tick_index<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): I32 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
2ReadRef
3Ret
}
public fees_growth_global<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 * u128 {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
2ReadRef
3MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
4ImmBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
5ReadRef
6Ret
}
public protocol_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
2ReadRef
3MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
4ImmBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
5ReadRef
6Ret
}
public tick_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &TickManager {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
2Ret
}
public position_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &PositionManager {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2Ret
}
public rewarder_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &RewarderManager {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
2Ret
}
public is_pause<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
2ReadRef
3Ret
}
public index<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[1](Pool.index: u64)
2ReadRef
3Ret
}
public url<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): String {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[2](Pool.url: String)
2ReadRef
3Ret
}
public borrow_tick<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32): &Tick {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
2MoveLoc[1](Arg1: I32)
3Call tick::borrow_tick(&TickManager, I32): &Tick
4Ret
}
public borrow_position_info<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): &PositionInfo {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2MoveLoc[1](Arg1: ID)
3Call position::borrow_position_info(&PositionManager, ID): &PositionInfo
4Ret
}
public swap_pay_amount<Ty0, Ty1>(Arg0: &FlashSwapReceipt<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &FlashSwapReceipt<Ty0, Ty1>)
1ImmBorrowFieldGeneric[20](FlashSwapReceipt.pay_amount: u64)
2ReadRef
3Ret
}
public ref_fee_amount<Ty0, Ty1>(Arg0: &FlashSwapReceipt<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &FlashSwapReceipt<Ty0, Ty1>)
1ImmBorrowFieldGeneric[21](FlashSwapReceipt.ref_fee_amount: u64)
2ReadRef
3Ret
}
public get_position_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u64 * u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2MoveLoc[1](Arg1: ID)
3Call position::borrow_position_info(&PositionManager, ID): &PositionInfo
4Call position::info_fee_owned(&PositionInfo): u64 * u64
5Ret
}
public get_position_points<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2MoveLoc[1](Arg1: ID)
3Call position::borrow_position_info(&PositionManager, ID): &PositionInfo
4Call position::info_points_owned(&PositionInfo): u128
5Ret
}
public get_position_rewards<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): vector<u64> {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2MoveLoc[1](Arg1: ID)
3Call position::rewards_amount_owned(&PositionManager, ID): vector<u64>
4Ret
}
public get_position_reward<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u64 {
L2: loc0: Option<u64>
L3: loc1: vector<u64>
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
2Call rewarder::rewarder_index<Ty2>(&RewarderManager): Option<u64>
3StLoc[2](loc0: Option<u64>)
4ImmBorrowLoc[2](loc0: Option<u64>)
5Call option::is_some<u64>(&Option<u64>): bool
6BrFalse(8)
B1:
7Branch(12)
B2:
8MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
9Pop
10LdConst[23](u64: 17)
11Abort
B3:
12MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
13ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
14MoveLoc[1](Arg1: ID)
15Call position::rewards_amount_owned(&PositionManager, ID): vector<u64>
16StLoc[3](loc1: vector<u64>)
17ImmBorrowLoc[3](loc1: vector<u64>)
18MutBorrowLoc[2](loc0: Option<u64>)
19Call option::extract<u64>(&mut Option<u64>): u64
20VecImmBorrow(22)
21ReadRef
22Ret
}
public is_position_exist<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): bool {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
2MoveLoc[1](Arg1: ID)
3Call position::is_position_exist(&PositionManager, ID): bool
4Ret
}
public calculated_swap_result_amount_out(Arg0: &CalculatedSwapResult): u64 {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[22](CalculatedSwapResult.amount_out: u64)
2ReadRef
3Ret
}
public calculated_swap_result_is_exceed(Arg0: &CalculatedSwapResult): bool {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[17](CalculatedSwapResult.is_exceed: bool)
2ReadRef
3Ret
}
public calculated_swap_result_amount_in(Arg0: &CalculatedSwapResult): u64 {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[20](CalculatedSwapResult.amount_in: u64)
2ReadRef
3Ret
}
public calculated_swap_result_after_sqrt_price(Arg0: &CalculatedSwapResult): u128 {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[25](CalculatedSwapResult.after_sqrt_price: u128)
2ReadRef
3Ret
}
public calculated_swap_result_fee_amount(Arg0: &CalculatedSwapResult): u64 {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[24](CalculatedSwapResult.fee_amount: u64)
2ReadRef
3Ret
}
public calculate_swap_result_step_results(Arg0: &CalculatedSwapResult): &vector<SwapStepResult> {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[18](CalculatedSwapResult.step_results: vector<SwapStepResult>)
2Ret
}
public calculated_swap_result_steps_length(Arg0: &CalculatedSwapResult): u64 {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[18](CalculatedSwapResult.step_results: vector<SwapStepResult>)
2VecLen(192)
3Ret
}
public calculated_swap_result_step_swap_result(Arg0: &CalculatedSwapResult, Arg1: u64): &SwapStepResult {
B0:
0MoveLoc[0](Arg0: &CalculatedSwapResult)
1ImmBorrowField[18](CalculatedSwapResult.step_results: vector<SwapStepResult>)
2MoveLoc[1](Arg1: u64)
3VecImmBorrow(192)
4Ret
}
public step_swap_result_amount_in(Arg0: &SwapStepResult): u64 {
B0:
0MoveLoc[0](Arg0: &SwapStepResult)
1ImmBorrowField[31](SwapStepResult.amount_in: u64)
2ReadRef
3Ret
}
public step_swap_result_amount_out(Arg0: &SwapStepResult): u64 {
B0:
0MoveLoc[0](Arg0: &SwapStepResult)
1ImmBorrowField[32](SwapStepResult.amount_out: u64)
2ReadRef
3Ret
}
public step_swap_result_fee_amount(Arg0: &SwapStepResult): u64 {
B0:
0MoveLoc[0](Arg0: &SwapStepResult)
1ImmBorrowField[33](SwapStepResult.fee_amount: u64)
2ReadRef
3Ret
}
public step_swap_result_current_sqrt_price(Arg0: &SwapStepResult): u128 {
B0:
0MoveLoc[0](Arg0: &SwapStepResult)
1ImmBorrowField[34](SwapStepResult.current_sqrt_price: u128)
2ReadRef
3Ret
}
public step_swap_result_target_sqrt_price(Arg0: &SwapStepResult): u128 {
B0:
0MoveLoc[0](Arg0: &SwapStepResult)
1ImmBorrowField[35](SwapStepResult.target_sqrt_price: u128)
2ReadRef
3Ret
}
public step_swap_result_current_liquidity(Arg0: &SwapStepResult): u128 {
B0:
0MoveLoc[0](Arg0: &SwapStepResult)
1ImmBorrowField[36](SwapStepResult.current_liquidity: u128)
2ReadRef
3Ret
}
public step_swap_result_remainder_amount(Arg0: &SwapStepResult): u64 {
B0:
0MoveLoc[0](Arg0: &SwapStepResult)
1ImmBorrowField[37](SwapStepResult.remainder_amount: u64)
2ReadRef
3Ret
}
public is_allow_swap<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[4](vector<u8>: "poo..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(17)
B1:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[14](Pool.id: UID)
8LdConst[4](vector<u8>: "poo..)
9Call string::utf8(vector<u8>): String
10Call dynamic_object_field::borrow<String, PoolStatus>(&UID, String): &PoolStatus
11ImmBorrowField[38](PoolStatus.status: Status)
12ImmBorrowField[39](Status.disable_swap: bool)
13ReadRef
14Not
15StLoc[1](loc0: bool)
16Branch(22)
B2:
17MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
18ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
19ReadRef
20Not
21StLoc[1](loc0: bool)
B3:
22MoveLoc[1](loc0: bool)
23Ret
}
public is_allow_add_liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[4](vector<u8>: "poo..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(17)
B1:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[14](Pool.id: UID)
8LdConst[4](vector<u8>: "poo..)
9Call string::utf8(vector<u8>): String
10Call dynamic_object_field::borrow<String, PoolStatus>(&UID, String): &PoolStatus
11ImmBorrowField[38](PoolStatus.status: Status)
12ImmBorrowField[40](Status.disable_add_liquidity: bool)
13ReadRef
14Not
15StLoc[1](loc0: bool)
16Branch(22)
B2:
17MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
18ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
19ReadRef
20Not
21StLoc[1](loc0: bool)
B3:
22MoveLoc[1](loc0: bool)
23Ret
}
public is_allow_remove_liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[4](vector<u8>: "poo..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(17)
B1:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[14](Pool.id: UID)
8LdConst[4](vector<u8>: "poo..)
9Call string::utf8(vector<u8>): String
10Call dynamic_object_field::borrow<String, PoolStatus>(&UID, String): &PoolStatus
11ImmBorrowField[38](PoolStatus.status: Status)
12ImmBorrowField[41](Status.disable_remove_liquidity: bool)
13ReadRef
14Not
15StLoc[1](loc0: bool)
16Branch(22)
B2:
17MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
18ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
19ReadRef
20Not
21StLoc[1](loc0: bool)
B3:
22MoveLoc[1](loc0: bool)
23Ret
}
public is_allow_flash_loan<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[4](vector<u8>: "poo..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(17)
B1:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[14](Pool.id: UID)
8LdConst[4](vector<u8>: "poo..)
9Call string::utf8(vector<u8>): String
10Call dynamic_object_field::borrow<String, PoolStatus>(&UID, String): &PoolStatus
11ImmBorrowField[38](PoolStatus.status: Status)
12ImmBorrowField[42](Status.disable_flash_loan: bool)
13ReadRef
14Not
15StLoc[1](loc0: bool)
16Branch(22)
B2:
17MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
18ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
19ReadRef
20Not
21StLoc[1](loc0: bool)
B3:
22MoveLoc[1](loc0: bool)
23Ret
}
public is_allow_collect_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[4](vector<u8>: "poo..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(17)
B1:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[14](Pool.id: UID)
8LdConst[4](vector<u8>: "poo..)
9Call string::utf8(vector<u8>): String
10Call dynamic_object_field::borrow<String, PoolStatus>(&UID, String): &PoolStatus
11ImmBorrowField[38](PoolStatus.status: Status)
12ImmBorrowField[43](Status.disable_collect_fee: bool)
13ReadRef
14Not
15StLoc[1](loc0: bool)
16Branch(22)
B2:
17MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
18ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
19ReadRef
20Not
21StLoc[1](loc0: bool)
B3:
22MoveLoc[1](loc0: bool)
23Ret
}
public is_allow_collect_reward<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[4](vector<u8>: "poo..)
3Call string::utf8(vector<u8>): String
4Call dynamic_object_field::exists_<String>(&UID, String): bool
5BrFalse(17)
B1:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[14](Pool.id: UID)
8LdConst[4](vector<u8>: "poo..)
9Call string::utf8(vector<u8>): String
10Call dynamic_object_field::borrow<String, PoolStatus>(&UID, String): &PoolStatus
11ImmBorrowField[38](PoolStatus.status: Status)
12ImmBorrowField[44](Status.disable_collect_reward: bool)
13ReadRef
14Not
15StLoc[1](loc0: bool)
16Branch(22)
B2:
17MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
18ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
19ReadRef
20Not
21StLoc[1](loc0: bool)
B3:
22MoveLoc[1](loc0: bool)
23Ret
}
public set_pool_status<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: bool, Arg3: bool, Arg4: bool, Arg5: bool, Arg6: bool, Arg7: bool, Arg8: &mut TxContext) {
L9: loc0: bool
L10: loc1: Option<Status>
L11: loc2: Status
L12: loc3: Status
L13: loc4: Status
L14: loc5: Status
L15: loc6: Option<Status>
L16: loc7: bool
L17: loc8: &mut PoolStatus
L18: loc9: PoolStatus
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::checked_package_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3CopyLoc[8](Arg8: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Call config::check_pool_manager_role(&GlobalConfig, address)
7CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
9ReadRef
10StLoc[16](loc7: bool)
11CopyLoc[2](Arg2: bool)
12BrFalse(16)
B1:
13LdTrue
14StLoc[9](loc0: bool)
15Branch(38)
B2:
16CopyLoc[3](Arg3: bool)
17BrFalse(21)
B3:
18LdTrue
19StLoc[9](loc0: bool)
20Branch(38)
B4:
21CopyLoc[4](Arg4: bool)
22BrFalse(26)
B5:
23LdTrue
24StLoc[9](loc0: bool)
25Branch(38)
B6:
26CopyLoc[5](Arg5: bool)
27BrFalse(31)
B7:
28LdTrue
29StLoc[9](loc0: bool)
30Branch(38)
B8:
31CopyLoc[6](Arg6: bool)
32BrFalse(36)
B9:
33LdTrue
34StLoc[9](loc0: bool)
35Branch(38)
B10:
36CopyLoc[7](Arg7: bool)
37StLoc[9](loc0: bool)
B11:
38MoveLoc[9](loc0: bool)
39CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
40MutBorrowFieldGeneric[16](Pool.is_pause: bool)
41WriteRef
42CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
43ImmBorrowFieldGeneric[14](Pool.id: UID)
44LdConst[4](vector<u8>: "poo..)
45Call string::utf8(vector<u8>): String
46Call dynamic_object_field::exists_<String>(&UID, String): bool
47BrFalse(98)
B12:
48MoveLoc[8](Arg8: &mut TxContext)
49Pop
50CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
51MutBorrowFieldGeneric[14](Pool.id: UID)
52LdConst[4](vector<u8>: "poo..)
53Call string::utf8(vector<u8>): String
54Call dynamic_object_field::borrow_mut<String, PoolStatus>(&mut UID, String): &mut PoolStatus
55StLoc[17](loc8: &mut PoolStatus)
56CopyLoc[17](loc8: &mut PoolStatus)
57ImmBorrowField[38](PoolStatus.status: Status)
58ReadRef
59StLoc[14](loc5: Status)
60MoveLoc[2](Arg2: bool)
61CopyLoc[17](loc8: &mut PoolStatus)
62MutBorrowField[38](PoolStatus.status: Status)
63MutBorrowField[40](Status.disable_add_liquidity: bool)
64WriteRef
65MoveLoc[3](Arg3: bool)
66CopyLoc[17](loc8: &mut PoolStatus)
67MutBorrowField[38](PoolStatus.status: Status)
68MutBorrowField[41](Status.disable_remove_liquidity: bool)
69WriteRef
70MoveLoc[4](Arg4: bool)
71CopyLoc[17](loc8: &mut PoolStatus)
72MutBorrowField[38](PoolStatus.status: Status)
73MutBorrowField[39](Status.disable_swap: bool)
74WriteRef
75MoveLoc[5](Arg5: bool)
76CopyLoc[17](loc8: &mut PoolStatus)
77MutBorrowField[38](PoolStatus.status: Status)
78MutBorrowField[42](Status.disable_flash_loan: bool)
79WriteRef
80MoveLoc[6](Arg6: bool)
81CopyLoc[17](loc8: &mut PoolStatus)
82MutBorrowField[38](PoolStatus.status: Status)
83MutBorrowField[43](Status.disable_collect_fee: bool)
84WriteRef
85MoveLoc[7](Arg7: bool)
86CopyLoc[17](loc8: &mut PoolStatus)
87MutBorrowField[38](PoolStatus.status: Status)
88MutBorrowField[44](Status.disable_collect_reward: bool)
89WriteRef
90MoveLoc[14](loc5: Status)
91Call option::some<Status>(Status): Option<Status>
92MoveLoc[17](loc8: &mut PoolStatus)
93ImmBorrowField[38](PoolStatus.status: Status)
94ReadRef
95StLoc[11](loc2: Status)
96StLoc[10](loc1: Option<Status>)
97Branch(123)
B13:
98MoveLoc[8](Arg8: &mut TxContext)
99Call object::new(&mut TxContext): UID
100MoveLoc[2](Arg2: bool)
101MoveLoc[3](Arg3: bool)
102MoveLoc[4](Arg4: bool)
103MoveLoc[5](Arg5: bool)
104MoveLoc[6](Arg6: bool)
105MoveLoc[7](Arg7: bool)
106Pack[3](Status)
107Pack[4](PoolStatus)
108StLoc[18](loc9: PoolStatus)
109ImmBorrowLoc[18](loc9: PoolStatus)
110ImmBorrowField[38](PoolStatus.status: Status)
111ReadRef
112StLoc[12](loc3: Status)
113CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
114MutBorrowFieldGeneric[14](Pool.id: UID)
115LdConst[4](vector<u8>: "poo..)
116Call string::utf8(vector<u8>): String
117MoveLoc[18](loc9: PoolStatus)
118Call dynamic_object_field::add<String, PoolStatus>(&mut UID, String, PoolStatus)
119Call option::none<Status>(): Option<Status>
120MoveLoc[12](loc3: Status)
121StLoc[11](loc2: Status)
122StLoc[10](loc1: Option<Status>)
B14:
123MoveLoc[10](loc1: Option<Status>)
124MoveLoc[11](loc2: Status)
125StLoc[13](loc4: Status)
126StLoc[15](loc6: Option<Status>)
127CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
128FreezeRef
129Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
130MoveLoc[16](loc7: bool)
131MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
132ImmBorrowFieldGeneric[16](Pool.is_pause: bool)
133ReadRef
134MoveLoc[15](loc6: Option<Status>)
135MoveLoc[13](loc4: Status)
136Pack[26](UpdatePoolStatusEvent)
137Call event::emit<UpdatePoolStatusEvent>(UpdatePoolStatusEvent)
138Ret
}
add_liquidity_internal<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut Position, Arg2: bool, Arg3: u128, Arg4: u64, Arg5: bool, Arg6: u64): AddLiquidityReceipt<Ty0, Ty1> {
L7: loc0: u128
L8: loc1: u64
L9: loc2: u64
L10: loc3: bool
L11: loc4: u128
L12: loc5: u64
L13: loc6: u64
L14: loc7: u64
L15: loc8: u64
L16: loc9: u128
L17: loc10: u128
L18: loc11: u128
L19: loc12: u128
L20: loc13: ID
L21: loc14: vector<u128>
L22: loc15: I32
L23: loc16: I32
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1FreezeRef
2Call is_allow_add_liquidity<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
3BrFalse(5)
B1:
4Branch(11)
B2:
5MoveLoc[1](Arg1: &mut Position)
6Pop
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8Pop
9LdConst[31](u64: 25)
10Abort
B3:
11CopyLoc[1](Arg1: &mut Position)
12FreezeRef
13Call object::id<Position>(&Position): ID
14StLoc[20](loc13: ID)
15CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
16Call mark_pending_add_liquidity<Ty0, Ty1>(&mut Pool<Ty0, Ty1>)
17CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
18MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
19CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
20ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
21ReadRef
22MoveLoc[6](Arg6: u64)
23Call rewarder::settle(&mut RewarderManager, u128, u64)
24CopyLoc[1](Arg1: &mut Position)
25FreezeRef
26Call position::tick_range(&Position): I32 * I32
27StLoc[23](loc16: I32)
28StLoc[22](loc15: I32)
29MoveLoc[2](Arg2: bool)
30BrFalse(46)
B4:
31CopyLoc[22](loc15: I32)
32CopyLoc[23](loc16: I32)
33CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
34ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
35ReadRef
36CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
37ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
38ReadRef
39MoveLoc[4](Arg4: u64)
40MoveLoc[5](Arg5: bool)
41Call clmm_math::get_liquidity_by_amount(I32, I32, I32, u128, u64, bool): u128 * u64 * u64
42StLoc[9](loc2: u64)
43StLoc[8](loc1: u64)
44StLoc[7](loc0: u128)
45Branch(65)
B5:
46CopyLoc[22](loc15: I32)
47CopyLoc[23](loc16: I32)
48CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
49ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
50ReadRef
51CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
52ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
53ReadRef
54CopyLoc[3](Arg3: u128)
55LdTrue
56Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64
57StLoc[14](loc7: u64)
58StLoc[12](loc5: u64)
59MoveLoc[3](Arg3: u128)
60MoveLoc[12](loc5: u64)
61MoveLoc[14](loc7: u64)
62StLoc[9](loc2: u64)
63StLoc[8](loc1: u64)
64StLoc[7](loc0: u128)
B6:
65MoveLoc[7](loc0: u128)
66MoveLoc[8](loc1: u64)
67MoveLoc[9](loc2: u64)
68StLoc[15](loc8: u64)
69StLoc[13](loc6: u64)
70StLoc[16](loc9: u128)
71CopyLoc[16](loc9: u128)
72LdU128(0)
73Gt
74BrFalse(76)
B7:
75Branch(82)
B8:
76MoveLoc[1](Arg1: &mut Position)
77Pop
78MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
79Pop
80LdConst[9](u64: 3)
81Abort
B9:
82CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
83FreezeRef
84CopyLoc[22](loc15: I32)
85CopyLoc[23](loc16: I32)
86Call get_fee_rewards_points_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128 * vector<u128> * u128
87StLoc[19](loc12: u128)
88StLoc[21](loc14: vector<u128>)
89StLoc[18](loc11: u128)
90StLoc[17](loc10: u128)
91CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
92MutBorrowFieldGeneric[0](Pool.position_manager: PositionManager)
93MoveLoc[1](Arg1: &mut Position)
94CopyLoc[16](loc9: u128)
95MoveLoc[17](loc10: u128)
96MoveLoc[18](loc11: u128)
97MoveLoc[19](loc12: u128)
98MoveLoc[21](loc14: vector<u128>)
99Call position::increase_liquidity(&mut PositionManager, &mut Position, u128, u128, u128, u128, vector<u128>): u128
100StLoc[11](loc4: u128)
101CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
102MutBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
103CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
104ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
105ReadRef
106CopyLoc[22](loc15: I32)
107CopyLoc[23](loc16: I32)
108CopyLoc[16](loc9: u128)
109CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
110ImmBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
111ReadRef
112CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
113ImmBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
114ReadRef
115CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
116ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
117Call rewarder::points_growth_global(&RewarderManager): u128
118CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
119ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
120Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>
121Call tick::increase_liquidity(&mut TickManager, I32, I32, I32, u128, u128, u128, u128, vector<u128>)
122CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
123ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
124ReadRef
125CopyLoc[22](loc15: I32)
126Call i32::gte(I32, I32): bool
127BrFalse(135)
B10:
128CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
129ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
130ReadRef
131CopyLoc[23](loc16: I32)
132Call i32::lt(I32, I32): bool
133StLoc[10](loc3: bool)
134Branch(137)
B11:
135LdFalse
136StLoc[10](loc3: bool)
B12:
137MoveLoc[10](loc3: bool)
138BrFalse(158)
B13:
139CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
140ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
141ReadRef
142CopyLoc[16](loc9: u128)
143Call math_u128::add_check(u128, u128): bool
144BrFalse(146)
B14:
145Branch(150)
B15:
146MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
147Pop
148LdConst[7](u64: 1)
149Abort
B16:
150CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
151ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
152ReadRef
153CopyLoc[16](loc9: u128)
154Add
155CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
156MutBorrowFieldGeneric[8](Pool.liquidity: u128)
157WriteRef
B17:
158CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
159FreezeRef
160Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
161MoveLoc[20](loc13: ID)
162MoveLoc[22](loc15: I32)
163MoveLoc[23](loc16: I32)
164MoveLoc[16](loc9: u128)
165MoveLoc[11](loc4: u128)
166CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
167ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
168ReadRef
169CopyLoc[13](loc6: u64)
170CopyLoc[15](loc8: u64)
171Pack[14](AddLiquidityV2Event)
172Call event::emit<AddLiquidityV2Event>(AddLiquidityV2Event)
173MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
174FreezeRef
175Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
176MoveLoc[13](loc6: u64)
177MoveLoc[15](loc8: u64)
178PackGeneric[1](AddLiquidityReceipt<Ty0, Ty1>)
179Ret
}
flash_swap_internal<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GlobalConfig, Arg2: ID, Arg3: u64, Arg4: bool, Arg5: bool, Arg6: u64, Arg7: u128, Arg8: &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {
L9: loc0: bool
L10: loc1: bool
L11: loc2: Balance<Ty0>
L12: loc3: Balance<Ty1>
L13: loc4: u128
L14: loc5: Balance<Ty0>
L15: loc6: Balance<Ty1>
L16: loc7: u64
L17: loc8: SwapResult
L18: loc9: u64
L19: loc10: u64
B0:
0CopyLoc[6](Arg6: u64)
1LdU64(0)
2Gt
3BrFalse(5)
B1:
4Branch(13)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
6Pop
7MoveLoc[1](Arg1: &GlobalConfig)
8Pop
9MoveLoc[8](Arg8: &Clock)
10Pop
11LdConst[6](u64: 0)
12Abort
B3:
13CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
14MutBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
15CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
16ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
17ReadRef
18MoveLoc[8](Arg8: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20LdU64(1000)
21Div
22Call rewarder::settle(&mut RewarderManager, u128, u64)
23CopyLoc[4](Arg4: bool)
24BrFalse(47)
B4:
25CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
26ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
27ReadRef
28CopyLoc[7](Arg7: u128)
29Gt
30BrFalse(36)
B5:
31CopyLoc[7](Arg7: u128)
32Call tick_math::min_sqrt_price(): u128
33Ge
34StLoc[9](loc0: bool)
35Branch(38)
B6:
36LdFalse
37StLoc[9](loc0: bool)
B7:
38MoveLoc[9](loc0: bool)
39BrFalse(41)
B8:
40Branch(69)
B9:
41MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
42Pop
43MoveLoc[1](Arg1: &GlobalConfig)
44Pop
45LdConst[17](u64: 11)
46Abort
B10:
47CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
48ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
49ReadRef
50CopyLoc[7](Arg7: u128)
51Lt
52BrFalse(58)
B11:
53CopyLoc[7](Arg7: u128)
54Call tick_math::max_sqrt_price(): u128
55Le
56StLoc[10](loc1: bool)
57Branch(60)
B12:
58LdFalse
59StLoc[10](loc1: bool)
B13:
60MoveLoc[10](loc1: bool)
61BrFalse(63)
B14:
62Branch(69)
B15:
63MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
64Pop
65MoveLoc[1](Arg1: &GlobalConfig)
66Pop
67LdConst[17](u64: 11)
68Abort
B16:
69CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
70ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
71ReadRef
72StLoc[13](loc4: u128)
73MoveLoc[1](Arg1: &GlobalConfig)
74Call config::protocol_fee_rate(&GlobalConfig): u64
75StLoc[16](loc7: u64)
76CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
77CopyLoc[4](Arg4: bool)
78MoveLoc[5](Arg5: bool)
79MoveLoc[7](Arg7: u128)
80MoveLoc[6](Arg6: u64)
81MoveLoc[16](loc7: u64)
82MoveLoc[3](Arg3: u64)
83Call swap_in_pool<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool, bool, u128, u64, u64, u64): SwapResult
84StLoc[17](loc8: SwapResult)
85CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
86ImmBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
87Call balance::value<Ty0>(&Balance<Ty0>): u64
88CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
89ImmBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
90Call balance::value<Ty1>(&Balance<Ty1>): u64
91StLoc[19](loc10: u64)
92StLoc[18](loc9: u64)
93CopyLoc[4](Arg4: bool)
94BrFalse(105)
B17:
95Call balance::zero<Ty0>(): Balance<Ty0>
96CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
97MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
98ImmBorrowLoc[17](loc8: SwapResult)
99ImmBorrowField[21](SwapResult.amount_out: u64)
100ReadRef
101Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
102StLoc[12](loc3: Balance<Ty1>)
103StLoc[11](loc2: Balance<Ty0>)
104Branch(114)
B18:
105CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
106MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
107ImmBorrowLoc[17](loc8: SwapResult)
108ImmBorrowField[21](SwapResult.amount_out: u64)
109ReadRef
110Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
111Call balance::zero<Ty1>(): Balance<Ty1>
112StLoc[12](loc3: Balance<Ty1>)
113StLoc[11](loc2: Balance<Ty0>)
B19:
114MoveLoc[11](loc2: Balance<Ty0>)
115MoveLoc[12](loc3: Balance<Ty1>)
116StLoc[15](loc6: Balance<Ty1>)
117StLoc[14](loc5: Balance<Ty0>)
118ImmBorrowLoc[17](loc8: SwapResult)
119ImmBorrowField[21](SwapResult.amount_out: u64)
120ReadRef
121LdU64(0)
122Gt
123BrFalse(125)
B20:
124Branch(129)
B21:
125MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
126Pop
127LdConst[24](u64: 18)
128Abort
B22:
129CopyLoc[4](Arg4: bool)
130CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
131FreezeRef
132Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
133CopyLoc[2](Arg2: ID)
134ImmBorrowLoc[17](loc8: SwapResult)
135ImmBorrowField[19](SwapResult.amount_in: u64)
136ReadRef
137ImmBorrowLoc[17](loc8: SwapResult)
138ImmBorrowField[23](SwapResult.fee_amount: u64)
139ReadRef
140Add
141ImmBorrowLoc[17](loc8: SwapResult)
142ImmBorrowField[21](SwapResult.amount_out: u64)
143ReadRef
144ImmBorrowLoc[17](loc8: SwapResult)
145ImmBorrowField[45](SwapResult.ref_fee_amount: u64)
146ReadRef
147ImmBorrowLoc[17](loc8: SwapResult)
148ImmBorrowField[23](SwapResult.fee_amount: u64)
149ReadRef
150MoveLoc[18](loc9: u64)
151MoveLoc[19](loc10: u64)
152MoveLoc[13](loc4: u128)
153CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
154ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
155ReadRef
156ImmBorrowLoc[17](loc8: SwapResult)
157ImmBorrowField[46](SwapResult.steps: u64)
158ReadRef
159Pack[17](SwapEvent)
160Call event::emit<SwapEvent>(SwapEvent)
161MoveLoc[14](loc5: Balance<Ty0>)
162MoveLoc[15](loc6: Balance<Ty1>)
163MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
164FreezeRef
165Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
166MoveLoc[4](Arg4: bool)
167MoveLoc[2](Arg2: ID)
168ImmBorrowLoc[17](loc8: SwapResult)
169ImmBorrowField[19](SwapResult.amount_in: u64)
170ReadRef
171ImmBorrowLoc[17](loc8: SwapResult)
172ImmBorrowField[23](SwapResult.fee_amount: u64)
173ReadRef
174Add
175ImmBorrowLoc[17](loc8: SwapResult)
176ImmBorrowField[45](SwapResult.ref_fee_amount: u64)
177ReadRef
178PackGeneric[2](FlashSwapReceipt<Ty0, Ty1>)
179Ret
}
flash_loan_internal<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID, Arg3: u64, Arg4: bool, Arg5: u64): Balance<Ty0> * Balance<Ty1> * FlashLoanReceipt {
L6: loc0: u64
L7: loc1: bool
L8: loc2: u64
L9: loc3: u64
L10: loc4: u64
L11: loc5: u64
L12: loc6: u64
L13: loc7: Balance<Ty0>
L14: loc8: Balance<Ty1>
L15: loc9: FlashLoanReceipt
L16: loc10: ID
L17: loc11: bool
L18: loc12: u64
L19: loc13: u64
L20: loc14: ID
L21: loc15: u64
L22: loc16: ID
L23: loc17: ID
L24: loc18: u64
L25: loc19: u64
L26: loc20: u64
L27: loc21: FlashLoanReceipt
L28: loc22: u64
L29: loc23: u64
L30: loc24: u64
B0:
0CopyLoc[5](Arg5: u64)
1LdU64(0)
2Gt
3BrFalse(5)
B1:
4Branch(11)
B2:
5MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
6Pop
7MoveLoc[0](Arg0: &GlobalConfig)
8Pop
9LdConst[6](u64: 0)
10Abort
B3:
11CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
12ImmBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
13Call balance::value<Ty0>(&Balance<Ty0>): u64
14CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
15ImmBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
16Call balance::value<Ty1>(&Balance<Ty1>): u64
17StLoc[30](loc24: u64)
18StLoc[29](loc23: u64)
19CopyLoc[4](Arg4: bool)
20BrFalse(34)
B4:
21CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
22ImmBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
23Call balance::value<Ty0>(&Balance<Ty0>): u64
24CopyLoc[5](Arg5: u64)
25Ge
26BrFalse(28)
B5:
27Branch(47)
B6:
28MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
29Pop
30MoveLoc[0](Arg0: &GlobalConfig)
31Pop
32LdConst[6](u64: 0)
33Abort
B7:
34CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
35ImmBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
36Call balance::value<Ty1>(&Balance<Ty1>): u64
37CopyLoc[5](Arg5: u64)
38Ge
39BrFalse(41)
B8:
40Branch(47)
B9:
41MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
42Pop
43MoveLoc[0](Arg0: &GlobalConfig)
44Pop
45LdConst[6](u64: 0)
46Abort
B10:
47CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
48ImmBorrowFieldGeneric[15](Pool.fee_rate: u64)
49ReadRef
50StLoc[25](loc19: u64)
51CopyLoc[5](Arg5: u64)
52MoveLoc[25](loc19: u64)
53Call clmm_math::fee_rate_denominator(): u64
54Call full_math_u64::mul_div_ceil(u64, u64, u64): u64
55StLoc[24](loc18: u64)
56CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
57CopyLoc[24](loc18: u64)
58MoveLoc[0](Arg0: &GlobalConfig)
59Call config::protocol_fee_rate(&GlobalConfig): u64
60CopyLoc[4](Arg4: bool)
61Call update_flash_loan_fee<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64, bool): u64
62StLoc[26](loc20: u64)
63CopyLoc[3](Arg3: u64)
64LdU64(0)
65Neq
66BrFalse(73)
B11:
67CopyLoc[26](loc20: u64)
68MoveLoc[3](Arg3: u64)
69LdConst[0](u64: 10000)
70Call full_math_u64::mul_div_floor(u64, u64, u64): u64
71StLoc[6](loc0: u64)
72Branch(75)
B12:
73LdU64(0)
74StLoc[6](loc0: u64)
B13:
75MoveLoc[6](loc0: u64)
76StLoc[28](loc22: u64)
77CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
78FreezeRef
79Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
80StLoc[16](loc10: ID)
81CopyLoc[4](Arg4: bool)
82StLoc[17](loc11: bool)
83CopyLoc[5](Arg5: u64)
84StLoc[18](loc12: u64)
85CopyLoc[24](loc18: u64)
86StLoc[19](loc13: u64)
87CopyLoc[2](Arg2: ID)
88StLoc[20](loc14: ID)
89CopyLoc[28](loc22: u64)
90StLoc[21](loc15: u64)
91MoveLoc[16](loc10: ID)
92MoveLoc[17](loc11: bool)
93MoveLoc[20](loc14: ID)
94MoveLoc[18](loc12: u64)
95MoveLoc[19](loc13: u64)
96MoveLoc[21](loc15: u64)
97Pack[8](FlashLoanReceipt)
98StLoc[27](loc21: FlashLoanReceipt)
99CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
100FreezeRef
101Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
102StLoc[22](loc16: ID)
103MoveLoc[2](Arg2: ID)
104StLoc[23](loc17: ID)
105CopyLoc[4](Arg4: bool)
106StLoc[7](loc1: bool)
107CopyLoc[5](Arg5: u64)
108StLoc[8](loc2: u64)
109MoveLoc[24](loc18: u64)
110StLoc[9](loc3: u64)
111CopyLoc[28](loc22: u64)
112StLoc[10](loc4: u64)
113MoveLoc[29](loc23: u64)
114StLoc[11](loc5: u64)
115MoveLoc[30](loc24: u64)
116StLoc[12](loc6: u64)
117MoveLoc[22](loc16: ID)
118MoveLoc[7](loc1: bool)
119MoveLoc[23](loc17: ID)
120MoveLoc[8](loc2: u64)
121MoveLoc[9](loc3: u64)
122MoveLoc[10](loc4: u64)
123MoveLoc[11](loc5: u64)
124MoveLoc[12](loc6: u64)
125Pack[25](FlashLoanEvent)
126Call event::emit<FlashLoanEvent>(FlashLoanEvent)
127MoveLoc[4](Arg4: bool)
128BrFalse(149)
B14:
129CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
130ImmBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
131ReadRef
132MoveLoc[26](loc20: u64)
133MoveLoc[28](loc22: u64)
134Sub
135Add
136CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
137MutBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
138WriteRef
139MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
140MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
141MoveLoc[5](Arg5: u64)
142Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
143Call balance::zero<Ty1>(): Balance<Ty1>
144MoveLoc[27](loc21: FlashLoanReceipt)
145StLoc[15](loc9: FlashLoanReceipt)
146StLoc[14](loc8: Balance<Ty1>)
147StLoc[13](loc7: Balance<Ty0>)
148Branch(168)
B15:
149CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
150ImmBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
151ReadRef
152MoveLoc[26](loc20: u64)
153MoveLoc[28](loc22: u64)
154Sub
155Add
156CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
157MutBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
158WriteRef
159Call balance::zero<Ty0>(): Balance<Ty0>
160MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
161MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
162MoveLoc[5](Arg5: u64)
163Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
164MoveLoc[27](loc21: FlashLoanReceipt)
165StLoc[15](loc9: FlashLoanReceipt)
166StLoc[14](loc8: Balance<Ty1>)
167StLoc[13](loc7: Balance<Ty0>)
B16:
168MoveLoc[13](loc7: Balance<Ty0>)
169MoveLoc[14](loc8: Balance<Ty1>)
170MoveLoc[15](loc9: FlashLoanReceipt)
171Ret
}
swap_in_pool<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: bool, Arg2: bool, Arg3: u128, Arg4: u64, Arg5: u64, Arg6: u64): SwapResult {
L7: loc0: bool
L8: loc1: u128
L9: loc2: bool
L10: loc3: I32
L11: loc4: bool
L12: loc5: u64
L13: loc6: u64
L14: loc7: u64
L15: loc8: u128
L16: loc9: &Tick
L17: loc10: I32
L18: loc11: u128
L19: loc12: OptionU64
L20: loc13: OptionU64
L21: loc14: u128
L22: loc15: u64
L23: loc16: u64
L24: loc17: vector<u128>
L25: loc18: SwapResult
L26: loc19: u128
B0:
0CopyLoc[6](Arg6: u64)
1LdConst[0](u64: 10000)
2Le
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
6Pop
7LdConst[22](u64: 16)
8Abort
B3:
9Call default_swap_result(): SwapResult
10StLoc[25](loc18: SwapResult)
11MoveLoc[4](Arg4: u64)
12StLoc[23](loc16: u64)
13CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
14ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
15CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
16ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
17ReadRef
18CopyLoc[1](Arg1: bool)
19Call tick::first_score_for_swap(&TickManager, I32, bool): OptionU64
20StLoc[20](loc13: OptionU64)
21CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
22ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
23Call rewarder::points_growth_global(&RewarderManager): u128
24CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
25ImmBorrowFieldGeneric[7](Pool.rewarder_manager: RewarderManager)
26Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>
27StLoc[24](loc17: vector<u128>)
28StLoc[21](loc14: u128)
29LdU64(0)
30StLoc[22](loc15: u64)
B4:
31CopyLoc[23](loc16: u64)
32LdU64(0)
33Gt
34BrFalse(42)
B5:
35CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
36ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
37ReadRef
38CopyLoc[3](Arg3: u128)
39Neq
40StLoc[7](loc0: bool)
41Branch(44)
B6:
42LdFalse
43StLoc[7](loc0: bool)
B7:
44MoveLoc[7](loc0: bool)
45BrFalse(197)
B8:
46ImmBorrowLoc[20](loc13: OptionU64)
47Call option_u64::is_none(&OptionU64): bool
48BrFalse(53)
B9:
49MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
50Pop
51LdConst[10](u64: 4)
52Abort
B10:
53CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
54ImmBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
55ImmBorrowLoc[20](loc13: OptionU64)
56Call option_u64::borrow(&OptionU64): u64
57CopyLoc[1](Arg1: bool)
58Call tick::borrow_tick_for_swap(&TickManager, u64, bool): &Tick * OptionU64
59StLoc[19](loc12: OptionU64)
60StLoc[16](loc9: &Tick)
61MoveLoc[19](loc12: OptionU64)
62StLoc[20](loc13: OptionU64)
63CopyLoc[16](loc9: &Tick)
64Call tick::index(&Tick): I32
65MoveLoc[16](loc9: &Tick)
66Call tick::sqrt_price(&Tick): u128
67StLoc[18](loc11: u128)
68StLoc[17](loc10: I32)
69CopyLoc[1](Arg1: bool)
70BrFalse(76)
B11:
71CopyLoc[3](Arg3: u128)
72CopyLoc[18](loc11: u128)
73Call math_u128::max(u128, u128): u128
74StLoc[8](loc1: u128)
75Branch(80)
B12:
76CopyLoc[3](Arg3: u128)
77CopyLoc[18](loc11: u128)
78Call math_u128::min(u128, u128): u128
79StLoc[8](loc1: u128)
B13:
80MoveLoc[8](loc1: u128)
81StLoc[26](loc19: u128)
82CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
83ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
84ReadRef
85CopyLoc[26](loc19: u128)
86CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
87ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
88ReadRef
89CopyLoc[23](loc16: u64)
90CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
91ImmBorrowFieldGeneric[15](Pool.fee_rate: u64)
92ReadRef
93CopyLoc[1](Arg1: bool)
94CopyLoc[2](Arg2: bool)
95Call clmm_math::compute_swap_step(u128, u128, u128, u64, u64, bool, bool): u64 * u64 * u128 * u64
96StLoc[14](loc7: u64)
97StLoc[15](loc8: u128)
98StLoc[13](loc6: u64)
99StLoc[12](loc5: u64)
100CopyLoc[12](loc5: u64)
101LdU64(0)
102Neq
103BrFalse(107)
B14:
104LdTrue
105StLoc[9](loc2: bool)
106Branch(111)
B15:
107CopyLoc[14](loc7: u64)
108LdU64(0)
109Neq
110StLoc[9](loc2: bool)
B16:
111MoveLoc[9](loc2: bool)
112BrFalse(139)
B17:
113CopyLoc[2](Arg2: bool)
114BrFalse(122)
B18:
115MoveLoc[23](loc16: u64)
116CopyLoc[12](loc5: u64)
117Call check_remainer_amount_sub(u64, u64): u64
118CopyLoc[14](loc7: u64)
119Call check_remainer_amount_sub(u64, u64): u64
120StLoc[23](loc16: u64)
121Branch(126)
B19:
122MoveLoc[23](loc16: u64)
123CopyLoc[13](loc6: u64)
124Call check_remainer_amount_sub(u64, u64): u64
125StLoc[23](loc16: u64)
B20:
126MutBorrowLoc[25](loc18: SwapResult)
127MoveLoc[12](loc5: u64)
128MoveLoc[13](loc6: u64)
129CopyLoc[14](loc7: u64)
130Call update_swap_result(&mut SwapResult, u64, u64, u64)
131MoveLoc[22](loc15: u64)
132CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
133MoveLoc[14](loc7: u64)
134CopyLoc[5](Arg5: u64)
135CopyLoc[1](Arg1: bool)
136Call update_pool_fee<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64, bool): u64
137Add
138StLoc[22](loc15: u64)
B21:
139CopyLoc[15](loc8: u128)
140MoveLoc[18](loc11: u128)
141Eq
142BrFalse(181)
B22:
143MoveLoc[26](loc19: u128)
144CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
145MutBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
146WriteRef
147CopyLoc[1](Arg1: bool)
148BrFalse(155)
B23:
149CopyLoc[17](loc10: I32)
150LdU32(1)
151Call i32::from(u32): I32
152Call i32::sub(I32, I32): I32
153StLoc[10](loc3: I32)
154Branch(157)
B24:
155CopyLoc[17](loc10: I32)
156StLoc[10](loc3: I32)
B25:
157MoveLoc[10](loc3: I32)
158CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
159MutBorrowFieldGeneric[10](Pool.current_tick_index: I32)
160WriteRef
161CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
162MutBorrowFieldGeneric[9](Pool.tick_manager: TickManager)
163MoveLoc[17](loc10: I32)
164CopyLoc[1](Arg1: bool)
165CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
166ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
167ReadRef
168CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
169ImmBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
170ReadRef
171CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
172ImmBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
173ReadRef
174CopyLoc[21](loc14: u128)
175CopyLoc[24](loc17: vector<u128>)
176Call tick::cross_by_swap(&mut TickManager, I32, bool, u128, u128, u128, u128, vector<u128>): u128
177CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
178MutBorrowFieldGeneric[8](Pool.liquidity: u128)
179WriteRef
180Branch(31)
B26:
181CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
182ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
183ReadRef
184CopyLoc[15](loc8: u128)
185Neq
186BrFalse(31)
B27:
187CopyLoc[15](loc8: u128)
188CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
189MutBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)
190WriteRef
191MoveLoc[15](loc8: u128)
192Call tick_math::get_tick_at_sqrt_price(u128): I32
193CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
194MutBorrowFieldGeneric[10](Pool.current_tick_index: I32)
195WriteRef
196Branch(31)
B28:
197CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
198ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
199ReadRef
200Call tick_math::min_tick(): I32
201Call i32::lt(I32, I32): bool
202BrFalse(206)
B29:
203LdTrue
204StLoc[11](loc4: bool)
205Branch(212)
B30:
206CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
207ImmBorrowFieldGeneric[10](Pool.current_tick_index: I32)
208ReadRef
209Call tick_math::max_tick(): I32
210Call i32::gte(I32, I32): bool
211StLoc[11](loc4: bool)
B31:
212MoveLoc[11](loc4: bool)
213BrFalse(218)
B32:
214MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
215Pop
216LdConst[36](u64: 30)
217Abort
B33:
218CopyLoc[22](loc15: u64)
219MoveLoc[6](Arg6: u64)
220LdConst[0](u64: 10000)
221Call full_math_u64::mul_div_floor(u64, u64, u64): u64
222MutBorrowLoc[25](loc18: SwapResult)
223MutBorrowField[45](SwapResult.ref_fee_amount: u64)
224WriteRef
225MoveLoc[1](Arg1: bool)
226BrFalse(255)
B34:
227CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
228ImmBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
229ReadRef
230CopyLoc[22](loc15: u64)
231ImmBorrowLoc[25](loc18: SwapResult)
232ImmBorrowField[45](SwapResult.ref_fee_amount: u64)
233ReadRef
234Sub
235Call math_u64::add_check(u64, u64): bool
236BrFalse(238)
B35:
237Branch(242)
B36:
238MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
239Pop
240LdConst[14](u64: 8)
241Abort
B37:
242CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
243ImmBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
244ReadRef
245MoveLoc[22](loc15: u64)
246ImmBorrowLoc[25](loc18: SwapResult)
247ImmBorrowField[45](SwapResult.ref_fee_amount: u64)
248ReadRef
249Sub
250Add
251MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
252MutBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
253WriteRef
254Branch(282)
B38:
255CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
256ImmBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
257ReadRef
258CopyLoc[22](loc15: u64)
259ImmBorrowLoc[25](loc18: SwapResult)
260ImmBorrowField[45](SwapResult.ref_fee_amount: u64)
261ReadRef
262Sub
263Call math_u64::add_check(u64, u64): bool
264BrFalse(266)
B39:
265Branch(270)
B40:
266MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
267Pop
268LdConst[14](u64: 8)
269Abort
B41:
270CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
271ImmBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
272ReadRef
273MoveLoc[22](loc15: u64)
274ImmBorrowLoc[25](loc18: SwapResult)
275ImmBorrowField[45](SwapResult.ref_fee_amount: u64)
276ReadRef
277Sub
278Add
279MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
280MutBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
281WriteRef
B42:
282MoveLoc[25](loc18: SwapResult)
283Ret
}
update_swap_result(Arg0: &mut SwapResult, Arg1: u64, Arg2: u64, Arg3: u64) {
B0:
0CopyLoc[0](Arg0: &mut SwapResult)
1ImmBorrowField[19](SwapResult.amount_in: u64)
2ReadRef
3CopyLoc[1](Arg1: u64)
4Call math_u64::add_check(u64, u64): bool
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &mut SwapResult)
8Pop
9LdConst[12](u64: 6)
10Abort
B3:
11CopyLoc[0](Arg0: &mut SwapResult)
12ImmBorrowField[21](SwapResult.amount_out: u64)
13ReadRef
14CopyLoc[2](Arg2: u64)
15Call math_u64::add_check(u64, u64): bool
16BrFalse(18)
B4:
17Branch(22)
B5:
18MoveLoc[0](Arg0: &mut SwapResult)
19Pop
20LdConst[13](u64: 7)
21Abort
B6:
22CopyLoc[0](Arg0: &mut SwapResult)
23ImmBorrowField[23](SwapResult.fee_amount: u64)
24ReadRef
25CopyLoc[3](Arg3: u64)
26Call math_u64::add_check(u64, u64): bool
27BrFalse(29)
B7:
28Branch(33)
B8:
29MoveLoc[0](Arg0: &mut SwapResult)
30Pop
31LdConst[14](u64: 8)
32Abort
B9:
33CopyLoc[0](Arg0: &mut SwapResult)
34ImmBorrowField[19](SwapResult.amount_in: u64)
35ReadRef
36MoveLoc[1](Arg1: u64)
37Add
38CopyLoc[0](Arg0: &mut SwapResult)
39MutBorrowField[19](SwapResult.amount_in: u64)
40WriteRef
41CopyLoc[0](Arg0: &mut SwapResult)
42ImmBorrowField[21](SwapResult.amount_out: u64)
43ReadRef
44MoveLoc[2](Arg2: u64)
45Add
46CopyLoc[0](Arg0: &mut SwapResult)
47MutBorrowField[21](SwapResult.amount_out: u64)
48WriteRef
49CopyLoc[0](Arg0: &mut SwapResult)
50ImmBorrowField[23](SwapResult.fee_amount: u64)
51ReadRef
52MoveLoc[3](Arg3: u64)
53Add
54CopyLoc[0](Arg0: &mut SwapResult)
55MutBorrowField[23](SwapResult.fee_amount: u64)
56WriteRef
57CopyLoc[0](Arg0: &mut SwapResult)
58ImmBorrowField[46](SwapResult.steps: u64)
59ReadRef
60LdU64(1)
61Add
62MoveLoc[0](Arg0: &mut SwapResult)
63MutBorrowField[46](SwapResult.steps: u64)
64WriteRef
65Ret
}
update_pool_fee<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: bool): u64 {
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: bool)
4Call update_fee_growth<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64, bool): u64
5Ret
}
update_flash_loan_fee<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: bool): u64 {
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: bool)
4Call update_fee_growth<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64, bool): u64
5Ret
}
update_fee_growth<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: bool): u64 {
L4: loc0: bool
L5: loc1: u128
L6: loc2: u64
L7: loc3: u64
B0:
0CopyLoc[1](Arg1: u64)
1MoveLoc[2](Arg2: u64)
2LdConst[0](u64: 10000)
3Call full_math_u64::mul_div_ceil(u64, u64, u64): u64
4StLoc[7](loc3: u64)
5MoveLoc[1](Arg1: u64)
6CopyLoc[7](loc3: u64)
7Sub
8StLoc[6](loc2: u64)
9CopyLoc[6](loc2: u64)
10LdU64(0)
11Eq
12BrFalse(16)
B1:
13LdTrue
14StLoc[4](loc0: bool)
15Branch(22)
B2:
16CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
17ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
18ReadRef
19LdU128(0)
20Eq
21StLoc[4](loc0: bool)
B3:
22MoveLoc[4](loc0: bool)
23BrFalse(28)
B4:
24MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
25Pop
26MoveLoc[7](loc3: u64)
27Ret
B5:
28MoveLoc[6](loc2: u64)
29CastU128
30LdU8(64)
31Shl
32CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
33ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
34ReadRef
35Div
36StLoc[5](loc1: u128)
37MoveLoc[3](Arg3: bool)
38BrFalse(48)
B6:
39CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
40ImmBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
41ReadRef
42MoveLoc[5](loc1: u128)
43Call math_u128::wrapping_add(u128, u128): u128
44MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
45MutBorrowFieldGeneric[11](Pool.fee_growth_global_a: u128)
46WriteRef
47Branch(56)
B7:
48CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
49ImmBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
50ReadRef
51MoveLoc[5](loc1: u128)
52Call math_u128::wrapping_add(u128, u128): u128
53MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
54MutBorrowFieldGeneric[12](Pool.fee_growth_global_b: u128)
55WriteRef
B8:
56MoveLoc[7](loc3: u64)
57Ret
}
collect_protocol_fee_internal<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>): Balance<Ty0> * Balance<Ty1> {
L1: loc0: bool
L2: loc1: bool
L3: loc2: u64
L4: loc3: u64
L5: loc4: Balance<Ty0>
L6: loc5: Balance<Ty1>
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
2ReadRef
3StLoc[3](loc2: u64)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5ImmBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
6ReadRef
7StLoc[4](loc3: u64)
8CopyLoc[3](loc2: u64)
9LdU64(0)
10Gt
11BrFalse(15)
B1:
12LdTrue
13StLoc[1](loc0: bool)
14Branch(19)
B2:
15CopyLoc[4](loc3: u64)
16LdU64(0)
17Gt
18StLoc[1](loc0: bool)
B3:
19MoveLoc[1](loc0: bool)
20BrFalse(22)
B4:
21Branch(26)
B5:
22MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
23Pop
24LdConst[39](u64: 33)
25Abort
B6:
26CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
27ImmBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
28Call balance::value<Ty0>(&Balance<Ty0>): u64
29CopyLoc[3](loc2: u64)
30Ge
31BrFalse(39)
B7:
32CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
33ImmBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
34Call balance::value<Ty1>(&Balance<Ty1>): u64
35CopyLoc[4](loc3: u64)
36Ge
37StLoc[2](loc1: bool)
38Branch(41)
B8:
39LdFalse
40StLoc[2](loc1: bool)
B9:
41MoveLoc[2](loc1: bool)
42BrFalse(44)
B10:
43Branch(48)
B11:
44MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
45Pop
46LdConst[40](u64: 34)
47Abort
B12:
48CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
49MutBorrowFieldGeneric[5](Pool.coin_a: Balance<Ty0>)
50CopyLoc[3](loc2: u64)
51Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
52StLoc[5](loc4: Balance<Ty0>)
53CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
54MutBorrowFieldGeneric[6](Pool.coin_b: Balance<Ty1>)
55CopyLoc[4](loc3: u64)
56Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
57StLoc[6](loc5: Balance<Ty1>)
58LdU64(0)
59CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
60MutBorrowFieldGeneric[18](Pool.fee_protocol_coin_a: u64)
61WriteRef
62LdU64(0)
63CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
64MutBorrowFieldGeneric[19](Pool.fee_protocol_coin_b: u64)
65WriteRef
66MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
67FreezeRef
68Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
69MoveLoc[3](loc2: u64)
70MoveLoc[4](loc3: u64)
71Pack[18](CollectProtocolFeeEvent)
72Call event::emit<CollectProtocolFeeEvent>(CollectProtocolFeeEvent)
73MoveLoc[5](loc4: Balance<Ty0>)
74MoveLoc[6](loc5: Balance<Ty1>)
75Ret
}
mark_pending_add_liquidity<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>) {
L1: loc0: &mut u64
L2: loc1: vector<u8>
B0:
0LdConst[5](vector<u8>: "pen..)
1StLoc[2](loc1: vector<u8>)
2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
3ImmBorrowFieldGeneric[14](Pool.id: UID)
4CopyLoc[2](loc1: vector<u8>)
5Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
6Not
7BrFalse(14)
B1:
8MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
9MutBorrowFieldGeneric[14](Pool.id: UID)
10MoveLoc[2](loc1: vector<u8>)
11LdU64(1)
12Call dynamic_field::add<vector<u8>, u64>(&mut UID, vector<u8>, u64)
13Branch(25)
B2:
14MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
15MutBorrowFieldGeneric[14](Pool.id: UID)
16MoveLoc[2](loc1: vector<u8>)
17Call dynamic_field::borrow_mut<vector<u8>, u64>(&mut UID, vector<u8>): &mut u64
18StLoc[1](loc0: &mut u64)
19CopyLoc[1](loc0: &mut u64)
20ReadRef
21LdU64(1)
22Add
23MoveLoc[1](loc0: &mut u64)
24WriteRef
B3:
25Ret
}
clear_pending_add_liquidity<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>) {
L1: loc0: &mut u64
L2: loc1: vector<u8>
B0:
0LdConst[5](vector<u8>: "pen..)
1StLoc[2](loc1: vector<u8>)
2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
3MutBorrowFieldGeneric[14](Pool.id: UID)
4CopyLoc[2](loc1: vector<u8>)
5Call dynamic_field::borrow_mut<vector<u8>, u64>(&mut UID, vector<u8>): &mut u64
6StLoc[1](loc0: &mut u64)
7CopyLoc[1](loc0: &mut u64)
8ReadRef
9LdU64(1)
10Sub
11CopyLoc[1](loc0: &mut u64)
12WriteRef
13MoveLoc[1](loc0: &mut u64)
14ReadRef
15LdU64(0)
16Eq
17BrFalse(24)
B1:
18MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
19MutBorrowFieldGeneric[14](Pool.id: UID)
20MoveLoc[2](loc1: vector<u8>)
21Call dynamic_field::remove<vector<u8>, u64>(&mut UID, vector<u8>): u64
22Pop
23Branch(26)
B2:
24MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
25Pop
B3:
26Ret
}
assert_no_pending_add_liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.id: UID)
2LdConst[5](vector<u8>: "pen..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[41](u64: 35)
8Abort
B3:
9Ret
}
check_remainer_amount_sub(Arg0: u64, Arg1: u64): u64 {
B0:
0CopyLoc[0](Arg0: u64)
1CopyLoc[1](Arg1: u64)
2Ge
3BrFalse(5)
B1:
4Branch(7)
B2:
5LdConst[11](u64: 5)
6Abort
B3:
7MoveLoc[0](Arg0: u64)
8MoveLoc[1](Arg1: u64)
9Sub
10Ret
}
default_swap_result(): SwapResult {
B0:
0LdU64(0)
1LdU64(0)
2LdU64(0)
3LdU64(0)
4LdU64(0)
5Pack[5](SwapResult)
6Ret
}
Constants [
0 => u64: 10000
1 => u64: 18446744073709551615
2 => u64: 1000000
3 => vector<u8>: "position_liquidity_snapshot" // interpreted as UTF8 string
4 => vector<u8>: "pool_status" // interpreted as UTF8 string
5 => vector<u8>: "pending_add_liquidity" // interpreted as UTF8 string
6 => u64: 0
7 => u64: 1
8 => u64: 2
9 => u64: 3
10 => u64: 4
11 => u64: 5
12 => u64: 6
13 => u64: 7
14 => u64: 8
15 => u64: 9
16 => u64: 10
17 => u64: 11
18 => u64: 12
19 => u64: 13
20 => u64: 14
21 => u64: 15
22 => u64: 16
23 => u64: 17
24 => u64: 18
25 => u64: 19
26 => u64: 20
27 => u64: 21
28 => u64: 22
29 => u64: 23
30 => u64: 24
31 => u64: 25
32 => u64: 26
33 => u64: 27
34 => u64: 28
35 => u64: 29
36 => u64: 30
37 => u64: 31
38 => u64: 32
39 => u64: 33
40 => u64: 34
41 => u64: 35
42 => u64: 36
43 => vector<u8>: "name" // interpreted as UTF8 string
44 => vector<u8>: "coin_a" // interpreted as UTF8 string
45 => vector<u8>: "coin_b" // interpreted as UTF8 string
46 => vector<u8>: "link" // interpreted as UTF8 string
47 => vector<u8>: "image_url" // interpreted as UTF8 string
48 => vector<u8>: "description" // interpreted as UTF8 string
49 => vector<u8>: "project_url" // interpreted as UTF8 string
50 => vector<u8>: "creator" // interpreted as UTF8 string
51 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}