pool
Module0x8925…bce5
- Move path
- 0x91bf…9ca1::pool
- Functions
- 8720 public, 0 entry
- Structs
- 25
pool
- fee4
- fee10000bps1
- fee100bps1
- fee3000bps1
- fee500bps1
- full_math_u1286
- full_math_u326
- full_math_u646
- i12831
- i3230
- i6428
- math_bit2
- math_liquidity7
- math_sqrt_price8
- math_swap3
- math_tick7
- math_u12817
- math_u2565
- math_u647
- pool87
- pool_factory21
- pool_fetcher1
- position_manager37
- position_nft5
- reward_manager8
- string_tools5
- swap_router13
Bytecode5302 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1.pool {
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::pay;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::full_math_u128;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::i128;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::i32;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_bit;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_liquidity;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_sqrt_price;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_swap;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_tick;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_u128;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_u64;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::partner;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::string_tools;
struct Versioned has store, key {
id: UID,
version: u64
}
struct Tick has store, key {
id: UID,
liquidity_gross: u128,
liquidity_net: I128,
fee_growth_outside_a: u128,
fee_growth_outside_b: u128,
reward_growths_outside: vector<u128>,
initialized: bool
}
struct TickInfo has copy, drop {
id: ID,
tick_index: I32,
liquidity_gross: u128,
liquidity_net: I128,
fee_growth_outside_a: u128,
fee_growth_outside_b: u128,
reward_growths_outside: vector<u128>,
initialized: bool
}
struct PositionRewardInfo has store {
reward_growth_inside: u128,
amount_owed: u64
}
struct Position has store, key {
id: UID,
liquidity: u128,
fee_growth_inside_a: u128,
fee_growth_inside_b: u128,
tokens_owed_a: u64,
tokens_owed_b: u64,
reward_infos: vector<PositionRewardInfo>
}
struct PoolRewardVault<phantom Ty0> has store, key {
id: UID,
coin: Balance<Ty0>
}
struct PoolRewardInfo has store, key {
id: UID,
vault: address,
vault_coin_type: String,
emissions_per_second: u128,
growth_global: u128,
manager: address
}
struct Pool<phantom Ty0, phantom Ty1, phantom Ty2> has store, key {
id: UID,
coin_a: Balance<Ty0>,
coin_b: Balance<Ty1>,
protocol_fees_a: u64,
protocol_fees_b: u64,
sqrt_price: u128,
tick_current_index: I32,
tick_spacing: u32,
max_liquidity_per_tick: u128,
fee: u32,
fee_protocol: u32,
unlocked: bool,
fee_growth_global_a: u128,
fee_growth_global_b: u128,
liquidity: u128,
tick_map: Table<I32, u256>,
deploy_time_ms: u64,
reward_infos: vector<PoolRewardInfo>,
reward_last_updated_time_ms: u64
}
struct ComputeSwapState has copy, drop {
amount_a: u128,
amount_b: u128,
amount_specified_remaining: u128,
amount_calculated: u128,
sqrt_price: u128,
tick_current_index: I32,
fee_growth_global: u128,
protocol_fee: u128,
liquidity: u128,
fee_amount: u128
}
struct ComputeSwapStateV2 has copy, drop {
amount_a: u128,
amount_b: u128,
amount_specified_remaining: u128,
amount_calculated: u128,
sqrt_price: u128,
tick_current_index: I32,
fee_growth_global: u128,
protocol_fee: u128,
liquidity: u128,
fee_amount: u128,
partner_fee_amount: u128
}
struct FlashSwapReceipt<phantom Ty0, phantom Ty1> {
pool_id: ID,
a_to_b: bool,
pay_amount: u64
}
struct FlashSwapReceiptPartner<phantom Ty0, phantom Ty1> {
pool_id: ID,
a_to_b: bool,
pay_amount: u64,
partner_id: ID,
partner_fee_amount: u64
}
struct SwapEvent has copy, drop {
pool: ID,
recipient: address,
amount_a: u64,
amount_b: u64,
liquidity: u128,
tick_current_index: I32,
tick_pre_index: I32,
sqrt_price: u128,
protocol_fee: u64,
fee_amount: u64,
a_to_b: bool,
is_exact_in: bool
}
struct MintEvent has copy, drop {
pool: ID,
owner: address,
tick_lower_index: I32,
tick_upper_index: I32,
amount_a: u64,
amount_b: u64,
liquidity_delta: u128
}
struct BurnEvent has copy, drop {
pool: ID,
owner: address,
tick_lower_index: I32,
tick_upper_index: I32,
amount_a: u64,
amount_b: u64,
liquidity_delta: u128
}
struct TogglePoolStatusEvent has copy, drop {
pool: ID,
status: bool
}
struct UpdatePoolFeeProtocolEvent has copy, drop {
pool: ID,
fee_protocol: u32
}
struct CollectEvent has copy, drop {
pool: ID,
recipient: address,
tick_lower_index: I32,
tick_upper_index: I32,
amount_a: u64,
amount_b: u64
}
struct CollectProtocolFeeEvent has copy, drop {
pool: ID,
recipient: address,
amount_a: u64,
amount_b: u64
}
struct CollectRewardEvent has copy, drop {
pool: ID,
recipient: address,
tick_lower_index: I32,
tick_upper_index: I32,
amount: u64,
vault: ID,
reward_index: u64
}
struct CollectEventV2 has copy, drop {
pool: ID,
owner: address,
recipient: address,
tick_lower_index: I32,
tick_upper_index: I32,
amount_a: u64,
amount_b: u64
}
struct CollectRewardEventV2 has copy, drop {
pool: ID,
recipient: address,
owner: address,
tick_lower_index: I32,
tick_upper_index: I32,
amount: u64,
vault: ID,
reward_type: TypeName,
reward_index: u64
}
struct InitRewardEvent has copy, drop {
pool: ID,
reward_index: u64,
reward_vault: address,
reward_manager: address
}
struct UpdateRewardManagerEvent has copy, drop {
pool: ID,
reward_index: u64,
reward_manager: address
}
struct UpdateRewardEmissionsEvent has copy, drop {
pool: ID,
reward_index: u64,
reward_vault: address,
reward_manager: address,
reward_emissions_per_second: u128
}
struct AddRewardEvent has copy, drop {
pool: ID,
reward_index: u64,
reward_vault: address,
reward_manager: address,
amount: u64
}
struct RemoveRewardEvent has copy, drop {
pool: ID,
reward_index: u64,
reward_vault: address,
reward_manager: address,
amount: u64,
recipient: address
}
struct UpgradeEvent has copy, drop {
old_version: u64,
new_version: u64
}
struct MigratePositionEvent has copy, drop {
pool: ID,
old_key: String,
new_key: String
}
struct ModifyTickRewardEvent has copy, drop {
pool: ID,
old_reward: u128,
new_reward: u128
}
init(Arg0: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2LdConst[0](u64: 18)
3Pack[0](Versioned)
4Call transfer::share_object<Versioned>(Versioned)
5Ret
}
public(friend) upgrade(Arg0: &mut Versioned) {
L1: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut Versioned)
1ImmBorrowField[0](Versioned.version: u64)
2ReadRef
3StLoc[1](loc0: u64)
4CopyLoc[1](loc0: u64)
5LdConst[0](u64: 18)
6Lt
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &mut Versioned)
10Pop
11LdConst[18](u64: 22)
12Abort
B3:
13LdConst[0](u64: 18)
14MoveLoc[0](Arg0: &mut Versioned)
15MutBorrowField[0](Versioned.version: u64)
16WriteRef
17MoveLoc[1](loc0: u64)
18LdConst[0](u64: 18)
19Pack[27](UpgradeEvent)
20Call event::emit<UpgradeEvent>(UpgradeEvent)
21Ret
}
public version(Arg0: &Versioned): u64 {
B0:
0MoveLoc[0](Arg0: &Versioned)
1ImmBorrowField[0](Versioned.version: u64)
2ReadRef
3Ret
}
public check_version(Arg0: &Versioned) {
B0:
0LdConst[0](u64: 18)
1MoveLoc[0](Arg0: &Versioned)
2ImmBorrowField[0](Versioned.version: u64)
3ReadRef
4Ge
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[19](u64: 23)
8Abort
B3:
9Ret
}
public(friend) deploy_pool<Ty0, Ty1, Ty2>(Arg0: u32, Arg1: u32, Arg2: u128, Arg3: u32, Arg4: &Clock, Arg5: &mut TxContext): Pool<Ty0, Ty1, Ty2> {
L6: loc0: u128
L7: loc1: I32
B0:
0CopyLoc[2](Arg2: u128)
1Call math_tick::tick_index_from_sqrt_price(u128): I32
2StLoc[7](loc1: I32)
3CopyLoc[1](Arg1: u32)
4Call math_tick::max_liquidity_per_tick(u32): u128
5StLoc[6](loc0: u128)
6CopyLoc[5](Arg5: &mut TxContext)
7Call object::new(&mut TxContext): UID
8Call balance::zero<Ty0>(): Balance<Ty0>
9Call balance::zero<Ty1>(): Balance<Ty1>
10LdU64(0)
11LdU64(0)
12MoveLoc[2](Arg2: u128)
13MoveLoc[7](loc1: I32)
14MoveLoc[1](Arg1: u32)
15MoveLoc[6](loc0: u128)
16MoveLoc[0](Arg0: u32)
17MoveLoc[3](Arg3: u32)
18LdTrue
19LdU128(0)
20LdU128(0)
21LdU128(0)
22MoveLoc[5](Arg5: &mut TxContext)
23Call table::new<I32, u256>(&mut TxContext): Table<I32, u256>
24MoveLoc[4](Arg4: &Clock)
25Call clock::timestamp_ms(&Clock): u64
26VecPack(112, 0)
27LdU64(0)
28PackGeneric[0](Pool<Ty0, Ty1, Ty2>)
29Ret
}
public(friend) mint<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32, Arg4: u128, Arg5: &Clock, Arg6: &mut TxContext): u64 * u64 {
L7: loc0: bool
L8: loc1: I128
L9: loc2: u64
L10: loc3: I128
L11: loc4: u64
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
2ReadRef
3BrFalse(5)
B1:
4Branch(13)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6Pop
7MoveLoc[6](Arg6: &mut TxContext)
8Pop
9MoveLoc[5](Arg5: &Clock)
10Pop
11LdConst[7](u64: 8)
12Abort
B3:
13CopyLoc[4](Arg4: u128)
14LdU128(0)
15Gt
16BrFalse(18)
B4:
17Branch(26)
B5:
18MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
19Pop
20MoveLoc[6](Arg6: &mut TxContext)
21Pop
22MoveLoc[5](Arg5: &Clock)
23Pop
24LdConst[2](u64: 1)
25Abort
B6:
26CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
27CopyLoc[1](Arg1: address)
28CopyLoc[2](Arg2: I32)
29CopyLoc[3](Arg3: I32)
30CopyLoc[6](Arg6: &mut TxContext)
31Call try_init_position<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, &mut TxContext)
32CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
33CopyLoc[1](Arg1: address)
34CopyLoc[2](Arg2: I32)
35CopyLoc[3](Arg3: I32)
36CopyLoc[4](Arg4: u128)
37Call i128::from(u128): I128
38MoveLoc[5](Arg5: &Clock)
39MoveLoc[6](Arg6: &mut TxContext)
40Call modify_position<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, I128, &Clock, &mut TxContext): I128 * I128
41StLoc[10](loc3: I128)
42StLoc[8](loc1: I128)
43CopyLoc[8](loc1: I128)
44Call i128::is_neg(I128): bool
45Not
46BrFalse(52)
B7:
47CopyLoc[10](loc3: I128)
48Call i128::is_neg(I128): bool
49Not
50StLoc[7](loc0: bool)
51Branch(54)
B8:
52LdFalse
53StLoc[7](loc0: bool)
B9:
54MoveLoc[7](loc0: bool)
55BrFalse(57)
B10:
56Branch(61)
B11:
57MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
58Pop
59LdConst[3](u64: 3)
60Abort
B12:
61MoveLoc[8](loc1: I128)
62Call i128::abs_u128(I128): u128
63CastU64
64MoveLoc[10](loc3: I128)
65Call i128::abs_u128(I128): u128
66CastU64
67StLoc[11](loc4: u64)
68StLoc[9](loc2: u64)
69MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
70FreezeRef
71Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
72MoveLoc[1](Arg1: address)
73MoveLoc[2](Arg2: I32)
74MoveLoc[3](Arg3: I32)
75CopyLoc[9](loc2: u64)
76CopyLoc[11](loc4: u64)
77MoveLoc[4](Arg4: u128)
78Pack[13](MintEvent)
79Call event::emit<MintEvent>(MintEvent)
80MoveLoc[9](loc2: u64)
81MoveLoc[11](loc4: u64)
82Ret
}
public(friend) burn<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32, Arg4: u128, Arg5: &Clock, Arg6: &mut TxContext): u64 * u64 {
L7: loc0: u64
L8: loc1: I128
L9: loc2: u64
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
2ReadRef
3BrFalse(5)
B1:
4Branch(13)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6Pop
7MoveLoc[6](Arg6: &mut TxContext)
8Pop
9MoveLoc[5](Arg5: &Clock)
10Pop
11LdConst[7](u64: 8)
12Abort
B3:
13CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
14CopyLoc[1](Arg1: address)
15CopyLoc[2](Arg2: I32)
16CopyLoc[3](Arg3: I32)
17CopyLoc[4](Arg4: u128)
18Call i128::neg_from(u128): I128
19MoveLoc[5](Arg5: &Clock)
20MoveLoc[6](Arg6: &mut TxContext)
21Call modify_position<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, I128, &Clock, &mut TxContext): I128 * I128
22StLoc[8](loc1: I128)
23Call i128::abs_u128(I128): u128
24CastU64
25MoveLoc[8](loc1: I128)
26Call i128::abs_u128(I128): u128
27CastU64
28StLoc[9](loc2: u64)
29StLoc[7](loc0: u64)
30MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
31FreezeRef
32Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
33MoveLoc[1](Arg1: address)
34MoveLoc[2](Arg2: I32)
35MoveLoc[3](Arg3: I32)
36CopyLoc[7](loc0: u64)
37CopyLoc[9](loc2: u64)
38MoveLoc[4](Arg4: u128)
39Pack[14](BurnEvent)
40Call event::emit<BurnEvent>(BurnEvent)
41MoveLoc[7](loc0: u64)
42MoveLoc[9](loc2: u64)
43Ret
}
public(friend) swap<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: bool, Arg3: u128, Arg4: bool, Arg5: u128, Arg6: &Clock, Arg7: &mut TxContext): u128 * u128 {
L8: loc0: ComputeSwapStateV2
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: address)
2MoveLoc[2](Arg2: bool)
3MoveLoc[3](Arg3: u128)
4MoveLoc[4](Arg4: bool)
5MoveLoc[5](Arg5: u128)
6LdFalse
7LdU64(0)
8MoveLoc[6](Arg6: &Clock)
9MoveLoc[7](Arg7: &mut TxContext)
10Call compute_swap_result<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, bool, u128, bool, u128, bool, u64, &Clock, &mut TxContext): ComputeSwapStateV2
11StLoc[8](loc0: ComputeSwapStateV2)
12ImmBorrowLoc[8](loc0: ComputeSwapStateV2)
13ImmBorrowField[2](ComputeSwapStateV2.amount_a: u128)
14ReadRef
15ImmBorrowLoc[8](loc0: ComputeSwapStateV2)
16ImmBorrowField[3](ComputeSwapStateV2.amount_b: u128)
17ReadRef
18Ret
}
public flash_swap<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: bool, Arg3: u128, Arg4: bool, Arg5: u128, Arg6: &Clock, Arg7: &Versioned, Arg8: &mut TxContext): Coin<Ty0> * Coin<Ty1> * FlashSwapReceipt<Ty0, Ty1> {
L9: loc0: Coin<Ty0>
L10: loc1: Coin<Ty1>
L11: loc2: u64
L12: loc3: Balance<Ty1>
L13: loc4: u64
L14: loc5: ComputeSwapStateV2
B0:
0MoveLoc[7](Arg7: &Versioned)
1Call check_version(&Versioned)
2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
3ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
4ReadRef
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
8Pop
9MoveLoc[8](Arg8: &mut TxContext)
10Pop
11MoveLoc[6](Arg6: &Clock)
12Pop
13LdConst[7](u64: 8)
14Abort
B3:
15CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
16MoveLoc[1](Arg1: address)
17CopyLoc[2](Arg2: bool)
18MoveLoc[3](Arg3: u128)
19MoveLoc[4](Arg4: bool)
20MoveLoc[5](Arg5: u128)
21LdFalse
22LdU64(0)
23MoveLoc[6](Arg6: &Clock)
24CopyLoc[8](Arg8: &mut TxContext)
25Call compute_swap_result<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, bool, u128, bool, u128, bool, u64, &Clock, &mut TxContext): ComputeSwapStateV2
26StLoc[14](loc5: ComputeSwapStateV2)
27CopyLoc[2](Arg2: bool)
28BrFalse(50)
B4:
29CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
30MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
31ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
32ImmBorrowField[3](ComputeSwapStateV2.amount_b: u128)
33ReadRef
34CastU64
35Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
36StLoc[12](loc3: Balance<Ty1>)
37CopyLoc[8](Arg8: &mut TxContext)
38Call coin::zero<Ty0>(&mut TxContext): Coin<Ty0>
39MoveLoc[12](loc3: Balance<Ty1>)
40MoveLoc[8](Arg8: &mut TxContext)
41Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
42ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
43ImmBorrowField[2](ComputeSwapStateV2.amount_a: u128)
44ReadRef
45CastU64
46StLoc[11](loc2: u64)
47StLoc[10](loc1: Coin<Ty1>)
48StLoc[9](loc0: Coin<Ty0>)
49Branch(68)
B5:
50CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
51MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
52ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
53ImmBorrowField[2](ComputeSwapStateV2.amount_a: u128)
54ReadRef
55CastU64
56Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
57CopyLoc[8](Arg8: &mut TxContext)
58Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
59MoveLoc[8](Arg8: &mut TxContext)
60Call coin::zero<Ty1>(&mut TxContext): Coin<Ty1>
61ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
62ImmBorrowField[3](ComputeSwapStateV2.amount_b: u128)
63ReadRef
64CastU64
65StLoc[11](loc2: u64)
66StLoc[10](loc1: Coin<Ty1>)
67StLoc[9](loc0: Coin<Ty0>)
B6:
68MoveLoc[9](loc0: Coin<Ty0>)
69MoveLoc[10](loc1: Coin<Ty1>)
70MoveLoc[11](loc2: u64)
71StLoc[13](loc4: u64)
72MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
73FreezeRef
74Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
75MoveLoc[2](Arg2: bool)
76MoveLoc[13](loc4: u64)
77PackGeneric[1](FlashSwapReceipt<Ty0, Ty1>)
78Ret
}
public flash_swap_partner<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &Partner, Arg2: bool, Arg3: u128, Arg4: bool, Arg5: u128, Arg6: &Clock, Arg7: &Versioned, Arg8: &mut TxContext): Coin<Ty0> * Coin<Ty1> * FlashSwapReceiptPartner<Ty0, Ty1> {
L9: loc0: Coin<Ty0>
L10: loc1: Coin<Ty1>
L11: loc2: u64
L12: loc3: Balance<Ty1>
L13: loc4: u64
L14: loc5: ComputeSwapStateV2
B0:
0MoveLoc[7](Arg7: &Versioned)
1Call check_version(&Versioned)
2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
3ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
4ReadRef
5BrFalse(7)
B1:
6Branch(17)
B2:
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
8Pop
9MoveLoc[1](Arg1: &Partner)
10Pop
11MoveLoc[8](Arg8: &mut TxContext)
12Pop
13MoveLoc[6](Arg6: &Clock)
14Pop
15LdConst[7](u64: 8)
16Abort
B3:
17CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
18LdConst[29](address: 0x00..)
19CopyLoc[2](Arg2: bool)
20MoveLoc[3](Arg3: u128)
21MoveLoc[4](Arg4: bool)
22MoveLoc[5](Arg5: u128)
23LdFalse
24CopyLoc[1](Arg1: &Partner)
25CopyLoc[6](Arg6: &Clock)
26Call clock::timestamp_ms(&Clock): u64
27LdU64(1000)
28Div
29Call partner::current_ref_fee_rate(&Partner, u64): u64
30MoveLoc[6](Arg6: &Clock)
31CopyLoc[8](Arg8: &mut TxContext)
32Call compute_swap_result<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, bool, u128, bool, u128, bool, u64, &Clock, &mut TxContext): ComputeSwapStateV2
33StLoc[14](loc5: ComputeSwapStateV2)
34CopyLoc[2](Arg2: bool)
35BrFalse(57)
B4:
36CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
37MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
38ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
39ImmBorrowField[3](ComputeSwapStateV2.amount_b: u128)
40ReadRef
41CastU64
42Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
43StLoc[12](loc3: Balance<Ty1>)
44CopyLoc[8](Arg8: &mut TxContext)
45Call coin::zero<Ty0>(&mut TxContext): Coin<Ty0>
46MoveLoc[12](loc3: Balance<Ty1>)
47MoveLoc[8](Arg8: &mut TxContext)
48Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
49ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
50ImmBorrowField[2](ComputeSwapStateV2.amount_a: u128)
51ReadRef
52CastU64
53StLoc[11](loc2: u64)
54StLoc[10](loc1: Coin<Ty1>)
55StLoc[9](loc0: Coin<Ty0>)
56Branch(75)
B5:
57CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
58MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
59ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
60ImmBorrowField[2](ComputeSwapStateV2.amount_a: u128)
61ReadRef
62CastU64
63Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
64CopyLoc[8](Arg8: &mut TxContext)
65Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
66MoveLoc[8](Arg8: &mut TxContext)
67Call coin::zero<Ty1>(&mut TxContext): Coin<Ty1>
68ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
69ImmBorrowField[3](ComputeSwapStateV2.amount_b: u128)
70ReadRef
71CastU64
72StLoc[11](loc2: u64)
73StLoc[10](loc1: Coin<Ty1>)
74StLoc[9](loc0: Coin<Ty0>)
B6:
75MoveLoc[9](loc0: Coin<Ty0>)
76MoveLoc[10](loc1: Coin<Ty1>)
77MoveLoc[11](loc2: u64)
78StLoc[13](loc4: u64)
79MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
80FreezeRef
81Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
82MoveLoc[2](Arg2: bool)
83MoveLoc[13](loc4: u64)
84MoveLoc[1](Arg1: &Partner)
85Call object::id<Partner>(&Partner): ID
86ImmBorrowLoc[14](loc5: ComputeSwapStateV2)
87ImmBorrowField[6](ComputeSwapStateV2.partner_fee_amount: u128)
88ReadRef
89CastU64
90PackGeneric[2](FlashSwapReceiptPartner<Ty0, Ty1>)
91Ret
}
public repay_flash_swap<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: Coin<Ty1>, Arg3: FlashSwapReceipt<Ty0, Ty1>, Arg4: &Versioned) {
L5: loc0: bool
L6: loc1: Balance<Ty0>
L7: loc2: Balance<Ty1>
L8: loc3: u64
L9: loc4: ID
B0:
0MoveLoc[4](Arg4: &Versioned)
1Call check_version(&Versioned)
2MoveLoc[3](Arg3: FlashSwapReceipt<Ty0, Ty1>)
3UnpackGeneric[1](FlashSwapReceipt<Ty0, Ty1>)
4StLoc[8](loc3: u64)
5StLoc[5](loc0: bool)
6StLoc[9](loc4: ID)
7CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
8ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
9ReadRef
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
13Pop
14LdConst[7](u64: 8)
15Abort
B3:
16MoveLoc[9](loc4: ID)
17CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
18FreezeRef
19Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
20Eq
21BrFalse(23)
B4:
22Branch(27)
B5:
23MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
24Pop
25LdConst[20](u64: 24)
26Abort
B6:
27MoveLoc[1](Arg1: Coin<Ty0>)
28Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
29StLoc[6](loc1: Balance<Ty0>)
30MoveLoc[2](Arg2: Coin<Ty1>)
31Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
32StLoc[7](loc2: Balance<Ty1>)
33MoveLoc[5](loc0: bool)
34BrFalse(53)
B7:
35ImmBorrowLoc[6](loc1: Balance<Ty0>)
36Call balance::value<Ty0>(&Balance<Ty0>): u64
37MoveLoc[8](loc3: u64)
38Eq
39BrFalse(41)
B8:
40Branch(45)
B9:
41MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
42Pop
43LdConst[21](u64: 25)
44Abort
B10:
45MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
46MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
47MoveLoc[6](loc1: Balance<Ty0>)
48Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
49Pop
50MoveLoc[7](loc2: Balance<Ty1>)
51Call balance::destroy_zero<Ty1>(Balance<Ty1>)
52Branch(70)
B11:
53ImmBorrowLoc[7](loc2: Balance<Ty1>)
54Call balance::value<Ty1>(&Balance<Ty1>): u64
55MoveLoc[8](loc3: u64)
56Eq
57BrFalse(59)
B12:
58Branch(63)
B13:
59MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
60Pop
61LdConst[21](u64: 25)
62Abort
B14:
63MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
64MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
65MoveLoc[7](loc2: Balance<Ty1>)
66Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
67Pop
68MoveLoc[6](loc1: Balance<Ty0>)
69Call balance::destroy_zero<Ty0>(Balance<Ty0>)
B15:
70Ret
}
public repay_flash_swap_partner<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Partner, Arg2: Coin<Ty0>, Arg3: Coin<Ty1>, Arg4: FlashSwapReceiptPartner<Ty0, Ty1>, Arg5: &Versioned) {
L6: loc0: bool
L7: loc1: Balance<Ty0>
L8: loc2: Balance<Ty1>
L9: loc3: u64
L10: loc4: ID
L11: loc5: u64
L12: loc6: ID
B0:
0MoveLoc[5](Arg5: &Versioned)
1Call check_version(&Versioned)
2MoveLoc[4](Arg4: FlashSwapReceiptPartner<Ty0, Ty1>)
3UnpackGeneric[2](FlashSwapReceiptPartner<Ty0, Ty1>)
4StLoc[9](loc3: u64)
5StLoc[10](loc4: ID)
6StLoc[11](loc5: u64)
7StLoc[6](loc0: bool)
8StLoc[12](loc6: ID)
9CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
10ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
11ReadRef
12BrFalse(14)
B1:
13Branch(20)
B2:
14MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
15Pop
16MoveLoc[1](Arg1: &mut Partner)
17Pop
18LdConst[7](u64: 8)
19Abort
B3:
20MoveLoc[12](loc6: ID)
21CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
22FreezeRef
23Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
24Eq
25BrFalse(27)
B4:
26Branch(33)
B5:
27MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
28Pop
29MoveLoc[1](Arg1: &mut Partner)
30Pop
31LdConst[20](u64: 24)
32Abort
B6:
33MoveLoc[10](loc4: ID)
34CopyLoc[1](Arg1: &mut Partner)
35FreezeRef
36Call object::id<Partner>(&Partner): ID
37Eq
38BrFalse(40)
B7:
39Branch(46)
B8:
40MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
41Pop
42MoveLoc[1](Arg1: &mut Partner)
43Pop
44LdConst[23](u64: 27)
45Abort
B9:
46MoveLoc[2](Arg2: Coin<Ty0>)
47Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
48StLoc[7](loc1: Balance<Ty0>)
49MoveLoc[3](Arg3: Coin<Ty1>)
50Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
51StLoc[8](loc2: Balance<Ty1>)
52MoveLoc[6](loc0: bool)
53BrFalse(86)
B10:
54ImmBorrowLoc[7](loc1: Balance<Ty0>)
55Call balance::value<Ty0>(&Balance<Ty0>): u64
56MoveLoc[11](loc5: u64)
57Eq
58BrFalse(60)
B11:
59Branch(66)
B12:
60MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
61Pop
62MoveLoc[1](Arg1: &mut Partner)
63Pop
64LdConst[21](u64: 25)
65Abort
B13:
66CopyLoc[9](loc3: u64)
67LdU64(0)
68Gt
69BrFalse(76)
B14:
70MoveLoc[1](Arg1: &mut Partner)
71MutBorrowLoc[7](loc1: Balance<Ty0>)
72MoveLoc[9](loc3: u64)
73Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
74Call partner::receive_ref_fee<Ty0>(&mut Partner, Balance<Ty0>)
75Branch(78)
B15:
76MoveLoc[1](Arg1: &mut Partner)
77Pop
B16:
78MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
79MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
80MoveLoc[7](loc1: Balance<Ty0>)
81Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
82Pop
83MoveLoc[8](loc2: Balance<Ty1>)
84Call balance::destroy_zero<Ty1>(Balance<Ty1>)
85Branch(117)
B17:
86ImmBorrowLoc[8](loc2: Balance<Ty1>)
87Call balance::value<Ty1>(&Balance<Ty1>): u64
88MoveLoc[11](loc5: u64)
89Eq
90BrFalse(92)
B18:
91Branch(98)
B19:
92MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
93Pop
94MoveLoc[1](Arg1: &mut Partner)
95Pop
96LdConst[21](u64: 25)
97Abort
B20:
98CopyLoc[9](loc3: u64)
99LdU64(0)
100Gt
101BrFalse(108)
B21:
102MoveLoc[1](Arg1: &mut Partner)
103MutBorrowLoc[8](loc2: Balance<Ty1>)
104MoveLoc[9](loc3: u64)
105Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
106Call partner::receive_ref_fee<Ty1>(&mut Partner, Balance<Ty1>)
107Branch(110)
B22:
108MoveLoc[1](Arg1: &mut Partner)
109Pop
B23:
110MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
111MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
112MoveLoc[8](loc2: Balance<Ty1>)
113Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
114Pop
115MoveLoc[7](loc1: Balance<Ty0>)
116Call balance::destroy_zero<Ty0>(Balance<Ty0>)
B24:
117Ret
}
public flash_swap_pay_amount<Ty0, Ty1>(Arg0: &FlashSwapReceiptPartner<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &FlashSwapReceiptPartner<Ty0, Ty1>)
1ImmBorrowFieldGeneric[3](FlashSwapReceiptPartner.pay_amount: u64)
2ReadRef
3Ret
}
public(friend) compute_swap_result<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: bool, Arg3: u128, Arg4: bool, Arg5: u128, Arg6: bool, Arg7: u64, Arg8: &Clock, Arg9: &mut TxContext): ComputeSwapStateV2 {
L10: loc0: bool
L11: loc1: bool
L12: loc2: bool
L13: loc3: u128
L14: loc4: u128
L15: loc5: u128
L16: loc6: u128
L17: loc7: I32
L18: loc8: &mut Pool<Ty0, Ty1, Ty2>
L19: loc9: bool
L20: loc10: I32
L21: loc11: u128
L22: loc12: u128
L23: loc13: bool
L24: loc14: bool
L25: loc15: u128
L26: loc16: I32
L27: loc17: u128
L28: loc18: u128
L29: loc19: u128
L30: loc20: u128
L31: loc21: u128
L32: loc22: u128
L33: loc23: u128
L34: loc24: I128
L35: loc25: vector<u128>
L36: loc26: ComputeSwapStateV2
L37: loc27: u128
L38: loc28: u128
L39: loc29: u128
L40: loc30: bool
L41: loc31: u128
L42: loc32: u128
L43: loc33: I32
L44: loc34: u128
L45: loc35: I32
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
2ReadRef
3BrFalse(5)
B1:
4Branch(13)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6Pop
7MoveLoc[9](Arg9: &mut TxContext)
8Pop
9MoveLoc[8](Arg8: &Clock)
10Pop
11LdConst[7](u64: 8)
12Abort
B3:
13CopyLoc[3](Arg3: u128)
14LdU128(0)
15Neq
16BrFalse(18)
B4:
17Branch(26)
B5:
18MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
19Pop
20MoveLoc[9](Arg9: &mut TxContext)
21Pop
22MoveLoc[8](Arg8: &Clock)
23Pop
24LdConst[6](u64: 7)
25Abort
B6:
26CopyLoc[5](Arg5: u128)
27LdConst[27](u128: 4295..)
28Lt
29BrFalse(33)
B7:
30LdTrue
31StLoc[10](loc0: bool)
32Branch(37)
B8:
33CopyLoc[5](Arg5: u128)
34LdConst[28](u128: 7922..)
35Gt
36StLoc[10](loc0: bool)
B9:
37MoveLoc[10](loc0: bool)
38BrFalse(47)
B10:
39MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
40Pop
41MoveLoc[9](Arg9: &mut TxContext)
42Pop
43MoveLoc[8](Arg8: &Clock)
44Pop
45LdConst[15](u64: 19)
46Abort
B11:
47CopyLoc[2](Arg2: bool)
48BrFalse(56)
B12:
49CopyLoc[5](Arg5: u128)
50CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
51ImmBorrowFieldGeneric[4](Pool.sqrt_price: u128)
52ReadRef
53Gt
54StLoc[24](loc14: bool)
55Branch(58)
B13:
56LdFalse
57StLoc[24](loc14: bool)
B14:
58MoveLoc[24](loc14: bool)
59BrFalse(63)
B15:
60LdTrue
61StLoc[19](loc9: bool)
62Branch(77)
B16:
63CopyLoc[2](Arg2: bool)
64Not
65BrFalse(73)
B17:
66CopyLoc[5](Arg5: u128)
67CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
68ImmBorrowFieldGeneric[4](Pool.sqrt_price: u128)
69ReadRef
70Lt
71StLoc[23](loc13: bool)
72Branch(75)
B18:
73LdFalse
74StLoc[23](loc13: bool)
B19:
75MoveLoc[23](loc13: bool)
76StLoc[19](loc9: bool)
B20:
77MoveLoc[19](loc9: bool)
78BrFalse(87)
B21:
79MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
80Pop
81MoveLoc[9](Arg9: &mut TxContext)
82Pop
83MoveLoc[8](Arg8: &Clock)
84Pop
85LdConst[16](u64: 20)
86Abort
B22:
87CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
88MoveLoc[8](Arg8: &Clock)
89Call clock::timestamp_ms(&Clock): u64
90Call next_pool_reward_infos<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64): vector<u128>
91StLoc[35](loc25: vector<u128>)
92CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
93ImmBorrowFieldGeneric[5](Pool.tick_current_index: I32)
94ReadRef
95StLoc[45](loc35: I32)
96CopyLoc[3](Arg3: u128)
97StLoc[28](loc18: u128)
98CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
99ImmBorrowFieldGeneric[4](Pool.sqrt_price: u128)
100ReadRef
101StLoc[27](loc17: u128)
102CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
103ImmBorrowFieldGeneric[5](Pool.tick_current_index: I32)
104ReadRef
105StLoc[26](loc16: I32)
106CopyLoc[2](Arg2: bool)
107BrFalse(113)
B23:
108CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
109ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
110ReadRef
111StLoc[25](loc15: u128)
112Branch(117)
B24:
113CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
114ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
115ReadRef
116StLoc[25](loc15: u128)
B25:
117LdU128(0)
118LdU128(0)
119MoveLoc[28](loc18: u128)
120LdU128(0)
121MoveLoc[27](loc17: u128)
122MoveLoc[26](loc16: I32)
123MoveLoc[25](loc15: u128)
124LdU128(0)
125CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
126ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
127ReadRef
128LdU128(0)
129LdU128(0)
130Pack[9](ComputeSwapStateV2)
131StLoc[36](loc26: ComputeSwapStateV2)
B26:
132ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
133ImmBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
134ReadRef
135LdU128(0)
136Gt
137BrFalse(146)
B27:
138Branch(139)
B28:
139ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
140ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
141ReadRef
142CopyLoc[5](Arg5: u128)
143Neq
144StLoc[11](loc1: bool)
145Branch(148)
B29:
146LdFalse
147StLoc[11](loc1: bool)
B30:
148MoveLoc[11](loc1: bool)
149BrFalse(418)
B31:
150ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
151ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
152ReadRef
153StLoc[42](loc32: u128)
154CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
155ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
156ImmBorrowField[15](ComputeSwapStateV2.tick_current_index: I32)
157ReadRef
158CopyLoc[2](Arg2: bool)
159Call next_initialized_tick_within_one_word<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, bool): I32 * bool
160StLoc[40](loc30: bool)
161StLoc[43](loc33: I32)
162CopyLoc[43](loc33: I32)
163LdConst[24](u32: 443636)
164Call i32::neg_from(u32): I32
165Call i32::lt(I32, I32): bool
166BrFalse(171)
B32:
167LdConst[24](u32: 443636)
168Call i32::neg_from(u32): I32
169StLoc[43](loc33: I32)
170Branch(179)
B33:
171CopyLoc[43](loc33: I32)
172LdConst[24](u32: 443636)
173Call i32::from(u32): I32
174Call i32::gt(I32, I32): bool
175BrFalse(179)
B34:
176LdConst[24](u32: 443636)
177Call i32::from(u32): I32
178StLoc[43](loc33: I32)
B35:
179CopyLoc[43](loc33: I32)
180Call math_tick::sqrt_price_from_tick_index(I32): u128
181StLoc[41](loc31: u128)
182CopyLoc[2](Arg2: bool)
183BrFalse(189)
B36:
184CopyLoc[41](loc31: u128)
185CopyLoc[5](Arg5: u128)
186Lt
187StLoc[12](loc2: bool)
188Branch(193)
B37:
189CopyLoc[41](loc31: u128)
190CopyLoc[5](Arg5: u128)
191Gt
192StLoc[12](loc2: bool)
B38:
193MoveLoc[12](loc2: bool)
194BrFalse(198)
B39:
195CopyLoc[5](Arg5: u128)
196StLoc[13](loc3: u128)
197Branch(200)
B40:
198CopyLoc[41](loc31: u128)
199StLoc[13](loc3: u128)
B41:
200MoveLoc[13](loc3: u128)
201StLoc[44](loc34: u128)
202ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
203ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
204ReadRef
205MoveLoc[44](loc34: u128)
206ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
207ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
208ReadRef
209ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
210ImmBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
211ReadRef
212CopyLoc[4](Arg4: bool)
213CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
214ImmBorrowFieldGeneric[9](Pool.fee: u32)
215ReadRef
216Call math_swap::compute_swap(u128, u128, u128, u128, bool, u32): u128 * u128 * u128 * u128
217StLoc[39](loc29: u128)
218StLoc[38](loc28: u128)
219StLoc[37](loc27: u128)
220MutBorrowLoc[36](loc26: ComputeSwapStateV2)
221MutBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
222WriteRef
223CopyLoc[4](Arg4: bool)
224BrFalse(244)
B42:
225ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
226ImmBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
227ReadRef
228MoveLoc[37](loc27: u128)
229Sub
230CopyLoc[39](loc29: u128)
231Sub
232MutBorrowLoc[36](loc26: ComputeSwapStateV2)
233MutBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
234WriteRef
235ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
236ImmBorrowField[18](ComputeSwapStateV2.amount_calculated: u128)
237ReadRef
238MoveLoc[38](loc28: u128)
239Add
240MutBorrowLoc[36](loc26: ComputeSwapStateV2)
241MutBorrowField[18](ComputeSwapStateV2.amount_calculated: u128)
242WriteRef
243Branch(262)
B43:
244ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
245ImmBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
246ReadRef
247MoveLoc[38](loc28: u128)
248Sub
249MutBorrowLoc[36](loc26: ComputeSwapStateV2)
250MutBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
251WriteRef
252ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
253ImmBorrowField[18](ComputeSwapStateV2.amount_calculated: u128)
254ReadRef
255MoveLoc[37](loc27: u128)
256Add
257CopyLoc[39](loc29: u128)
258Add
259MutBorrowLoc[36](loc26: ComputeSwapStateV2)
260MutBorrowField[18](ComputeSwapStateV2.amount_calculated: u128)
261WriteRef
B44:
262ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
263ImmBorrowField[19](ComputeSwapStateV2.fee_amount: u128)
264ReadRef
265CopyLoc[39](loc29: u128)
266Add
267MutBorrowLoc[36](loc26: ComputeSwapStateV2)
268MutBorrowField[19](ComputeSwapStateV2.fee_amount: u128)
269WriteRef
270CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
271ImmBorrowFieldGeneric[10](Pool.fee_protocol: u32)
272ReadRef
273LdU32(0)
274Gt
275BrFalse(297)
B45:
276CopyLoc[39](loc29: u128)
277CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
278ImmBorrowFieldGeneric[10](Pool.fee_protocol: u32)
279ReadRef
280CastU128
281Mul
282LdU128(1000000)
283Div
284StLoc[30](loc20: u128)
285MoveLoc[39](loc29: u128)
286CopyLoc[30](loc20: u128)
287Sub
288StLoc[39](loc29: u128)
289ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
290ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
291ReadRef
292MoveLoc[30](loc20: u128)
293Call math_u128::wrapping_add(u128, u128): u128
294MutBorrowLoc[36](loc26: ComputeSwapStateV2)
295MutBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
296WriteRef
B46:
297ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
298ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
299ReadRef
300LdU128(0)
301Gt
302BrFalse(318)
B47:
303MoveLoc[39](loc29: u128)
304LdConst[25](u128: 1844..)
305ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
306ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
307ReadRef
308Call full_math_u128::mul_div_floor(u128, u128, u128): u128
309StLoc[33](loc23: u128)
310ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
311ImmBorrowField[22](ComputeSwapStateV2.fee_growth_global: u128)
312ReadRef
313MoveLoc[33](loc23: u128)
314Call math_u128::wrapping_add(u128, u128): u128
315MutBorrowLoc[36](loc26: ComputeSwapStateV2)
316MutBorrowField[22](ComputeSwapStateV2.fee_growth_global: u128)
317WriteRef
B48:
318ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
319ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
320ReadRef
321MoveLoc[41](loc31: u128)
322Eq
323BrFalse(395)
B49:
324MoveLoc[40](loc30: bool)
325BrFalse(380)
B50:
326CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
327ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
328ReadRef
329CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
330ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
331ReadRef
332StLoc[32](loc22: u128)
333StLoc[31](loc21: u128)
334CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
335StLoc[18](loc8: &mut Pool<Ty0, Ty1, Ty2>)
336CopyLoc[43](loc33: I32)
337StLoc[17](loc7: I32)
338CopyLoc[2](Arg2: bool)
339BrFalse(345)
B51:
340ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
341ImmBorrowField[22](ComputeSwapStateV2.fee_growth_global: u128)
342ReadRef
343StLoc[15](loc5: u128)
344Branch(347)
B52:
345MoveLoc[31](loc21: u128)
346StLoc[15](loc5: u128)
B53:
347MoveLoc[15](loc5: u128)
348StLoc[16](loc6: u128)
349CopyLoc[2](Arg2: bool)
350BrFalse(354)
B54:
351MoveLoc[32](loc22: u128)
352StLoc[14](loc4: u128)
353Branch(358)
B55:
354ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
355ImmBorrowField[22](ComputeSwapStateV2.fee_growth_global: u128)
356ReadRef
357StLoc[14](loc4: u128)
B56:
358MoveLoc[18](loc8: &mut Pool<Ty0, Ty1, Ty2>)
359MoveLoc[17](loc7: I32)
360MoveLoc[16](loc6: u128)
361MoveLoc[14](loc4: u128)
362ImmBorrowLoc[35](loc25: vector<u128>)
363CopyLoc[6](Arg6: bool)
364CopyLoc[9](Arg9: &mut TxContext)
365Call cross_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, u128, u128, &vector<u128>, bool, &mut TxContext): I128
366StLoc[34](loc24: I128)
367CopyLoc[2](Arg2: bool)
368BrFalse(372)
B57:
369MoveLoc[34](loc24: I128)
370Call i128::neg(I128): I128
371StLoc[34](loc24: I128)
B58:
372ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
373ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
374ReadRef
375MoveLoc[34](loc24: I128)
376Call math_liquidity::add_delta(u128, I128): u128
377MutBorrowLoc[36](loc26: ComputeSwapStateV2)
378MutBorrowField[16](ComputeSwapStateV2.liquidity: u128)
379WriteRef
B59:
380CopyLoc[2](Arg2: bool)
381BrFalse(388)
B60:
382MoveLoc[43](loc33: I32)
383LdU32(1)
384Call i32::from(u32): I32
385Call i32::sub(I32, I32): I32
386StLoc[20](loc10: I32)
387Branch(390)
B61:
388MoveLoc[43](loc33: I32)
389StLoc[20](loc10: I32)
B62:
390MoveLoc[20](loc10: I32)
391MutBorrowLoc[36](loc26: ComputeSwapStateV2)
392MutBorrowField[15](ComputeSwapStateV2.tick_current_index: I32)
393WriteRef
394Branch(408)
B63:
395ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
396ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
397ReadRef
398MoveLoc[42](loc32: u128)
399Neq
400BrFalse(408)
B64:
401ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
402ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
403ReadRef
404Call math_tick::tick_index_from_sqrt_price(u128): I32
405MutBorrowLoc[36](loc26: ComputeSwapStateV2)
406MutBorrowField[15](ComputeSwapStateV2.tick_current_index: I32)
407WriteRef
B65:
408ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
409ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
410ReadRef
411LdU128(0)
412Eq
413BrFalse(417)
B66:
414MoveLoc[9](Arg9: &mut TxContext)
415Pop
416Branch(418)
B67:
417Branch(132)
B68:
418MoveLoc[6](Arg6: bool)
419Not
420BrFalse(547)
B69:
421ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
422ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
423ReadRef
424LdU128(0)
425Gt
426BrFalse(428)
B70:
427Branch(432)
B71:
428MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
429Pop
430LdConst[22](u64: 26)
431Abort
B72:
432ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
433ImmBorrowField[15](ComputeSwapStateV2.tick_current_index: I32)
434ReadRef
435CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
436ImmBorrowFieldGeneric[5](Pool.tick_current_index: I32)
437ReadRef
438Call i32::eq(I32, I32): bool
439Not
440BrFalse(454)
B73:
441ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
442ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
443ReadRef
444CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
445MutBorrowFieldGeneric[4](Pool.sqrt_price: u128)
446WriteRef
447ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
448ImmBorrowField[15](ComputeSwapStateV2.tick_current_index: I32)
449ReadRef
450CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
451MutBorrowFieldGeneric[5](Pool.tick_current_index: I32)
452WriteRef
453Branch(460)
B74:
454ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
455ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
456ReadRef
457CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
458MutBorrowFieldGeneric[4](Pool.sqrt_price: u128)
459WriteRef
B75:
460CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
461ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
462ReadRef
463ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
464ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
465ReadRef
466Neq
467BrFalse(474)
B76:
468ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
469ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
470ReadRef
471CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
472MutBorrowFieldGeneric[8](Pool.liquidity: u128)
473WriteRef
B77:
474CopyLoc[7](Arg7: u64)
475LdU64(0)
476Gt
477BrFalse(488)
B78:
478ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
479ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
480ReadRef
481MoveLoc[7](Arg7: u64)
482CastU128
483LdU128(10000)
484Call full_math_u128::mul_div_floor(u128, u128, u128): u128
485MutBorrowLoc[36](loc26: ComputeSwapStateV2)
486MutBorrowField[6](ComputeSwapStateV2.partner_fee_amount: u128)
487WriteRef
B79:
488CopyLoc[2](Arg2: bool)
489BrFalse(519)
B80:
490ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
491ImmBorrowField[22](ComputeSwapStateV2.fee_growth_global: u128)
492ReadRef
493CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
494MutBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
495WriteRef
496ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
497ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
498ReadRef
499LdU128(0)
500Gt
501BrFalse(518)
B81:
502CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
503ImmBorrowFieldGeneric[11](Pool.protocol_fees_a: u64)
504ReadRef
505ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
506ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
507ReadRef
508CastU64
509Add
510ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
511ImmBorrowField[6](ComputeSwapStateV2.partner_fee_amount: u128)
512ReadRef
513CastU64
514Sub
515CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
516MutBorrowFieldGeneric[11](Pool.protocol_fees_a: u64)
517WriteRef
B82:
518Branch(547)
B83:
519ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
520ImmBorrowField[22](ComputeSwapStateV2.fee_growth_global: u128)
521ReadRef
522CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
523MutBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
524WriteRef
525ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
526ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
527ReadRef
528LdU128(0)
529Gt
530BrFalse(547)
B84:
531CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
532ImmBorrowFieldGeneric[12](Pool.protocol_fees_b: u64)
533ReadRef
534ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
535ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
536ReadRef
537CastU64
538Add
539ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
540ImmBorrowField[6](ComputeSwapStateV2.partner_fee_amount: u128)
541ReadRef
542CastU64
543Sub
544CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
545MutBorrowFieldGeneric[12](Pool.protocol_fees_b: u64)
546WriteRef
B85:
547CopyLoc[2](Arg2: bool)
548CopyLoc[4](Arg4: bool)
549Eq
550BrFalse(562)
B86:
551MoveLoc[3](Arg3: u128)
552ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
553ImmBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
554ReadRef
555Sub
556ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
557ImmBorrowField[18](ComputeSwapStateV2.amount_calculated: u128)
558ReadRef
559StLoc[22](loc12: u128)
560StLoc[21](loc11: u128)
561Branch(572)
B87:
562ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
563ImmBorrowField[18](ComputeSwapStateV2.amount_calculated: u128)
564ReadRef
565MoveLoc[3](Arg3: u128)
566ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
567ImmBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
568ReadRef
569Sub
570StLoc[22](loc12: u128)
571StLoc[21](loc11: u128)
B88:
572MoveLoc[21](loc11: u128)
573MoveLoc[22](loc12: u128)
574StLoc[29](loc19: u128)
575MutBorrowLoc[36](loc26: ComputeSwapStateV2)
576MutBorrowField[2](ComputeSwapStateV2.amount_a: u128)
577WriteRef
578MoveLoc[29](loc19: u128)
579MutBorrowLoc[36](loc26: ComputeSwapStateV2)
580MutBorrowField[3](ComputeSwapStateV2.amount_b: u128)
581WriteRef
582MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
583FreezeRef
584Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
585MoveLoc[1](Arg1: address)
586ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
587ImmBorrowField[2](ComputeSwapStateV2.amount_a: u128)
588ReadRef
589CastU64
590ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
591ImmBorrowField[3](ComputeSwapStateV2.amount_b: u128)
592ReadRef
593CastU64
594ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
595ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
596ReadRef
597ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
598ImmBorrowField[15](ComputeSwapStateV2.tick_current_index: I32)
599ReadRef
600MoveLoc[45](loc35: I32)
601ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
602ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
603ReadRef
604ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
605ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
606ReadRef
607CastU64
608ImmBorrowLoc[36](loc26: ComputeSwapStateV2)
609ImmBorrowField[19](ComputeSwapStateV2.fee_amount: u128)
610ReadRef
611CastU64
612MoveLoc[2](Arg2: bool)
613MoveLoc[4](Arg4: bool)
614Pack[12](SwapEvent)
615Call event::emit<SwapEvent>(SwapEvent)
616MoveLoc[36](loc26: ComputeSwapStateV2)
617Ret
}
public(friend) convert_state_v2_to_v1(Arg0: &ComputeSwapStateV2): ComputeSwapState {
B0:
0CopyLoc[0](Arg0: &ComputeSwapStateV2)
1ImmBorrowField[2](ComputeSwapStateV2.amount_a: u128)
2ReadRef
3CopyLoc[0](Arg0: &ComputeSwapStateV2)
4ImmBorrowField[3](ComputeSwapStateV2.amount_b: u128)
5ReadRef
6CopyLoc[0](Arg0: &ComputeSwapStateV2)
7ImmBorrowField[13](ComputeSwapStateV2.amount_specified_remaining: u128)
8ReadRef
9CopyLoc[0](Arg0: &ComputeSwapStateV2)
10ImmBorrowField[18](ComputeSwapStateV2.amount_calculated: u128)
11ReadRef
12CopyLoc[0](Arg0: &ComputeSwapStateV2)
13ImmBorrowField[14](ComputeSwapStateV2.sqrt_price: u128)
14ReadRef
15CopyLoc[0](Arg0: &ComputeSwapStateV2)
16ImmBorrowField[15](ComputeSwapStateV2.tick_current_index: I32)
17ReadRef
18CopyLoc[0](Arg0: &ComputeSwapStateV2)
19ImmBorrowField[22](ComputeSwapStateV2.fee_growth_global: u128)
20ReadRef
21CopyLoc[0](Arg0: &ComputeSwapStateV2)
22ImmBorrowField[21](ComputeSwapStateV2.protocol_fee: u128)
23ReadRef
24CopyLoc[0](Arg0: &ComputeSwapStateV2)
25ImmBorrowField[16](ComputeSwapStateV2.liquidity: u128)
26ReadRef
27MoveLoc[0](Arg0: &ComputeSwapStateV2)
28ImmBorrowField[19](ComputeSwapStateV2.fee_amount: u128)
29ReadRef
30Pack[8](ComputeSwapState)
31Ret
}
public(friend) toggle_pool_status<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
2ReadRef
3Not
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
5MutBorrowFieldGeneric[0](Pool.unlocked: bool)
6WriteRef
7CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
8FreezeRef
9Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
10MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
11ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
12ReadRef
13Pack[15](TogglePoolStatusEvent)
14Call event::emit<TogglePoolStatusEvent>(TogglePoolStatusEvent)
15Ret
}
public(friend) collect<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32, Arg4: u64, Arg5: u64, Arg6: &mut TxContext): u64 * u64 {
B0:
0LdU64(0)
1Abort
}
public(friend) collect_v2<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: address, Arg3: I32, Arg4: I32, Arg5: u64, Arg6: u64, Arg7: &mut TxContext): u64 * u64 {
L8: loc0: u64
L9: loc1: u64
L10: loc2: u64
L11: loc3: u64
L12: loc4: &mut Position
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1CopyLoc[2](Arg2: address)
2CopyLoc[3](Arg3: I32)
3CopyLoc[4](Arg4: I32)
4Call get_position_mut<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32): &mut Position
5StLoc[12](loc4: &mut Position)
6CopyLoc[5](Arg5: u64)
7CopyLoc[12](loc4: &mut Position)
8ImmBorrowField[25](Position.tokens_owed_a: u64)
9ReadRef
10Gt
11BrFalse(17)
B1:
12CopyLoc[12](loc4: &mut Position)
13ImmBorrowField[25](Position.tokens_owed_a: u64)
14ReadRef
15StLoc[8](loc0: u64)
16Branch(19)
B2:
17MoveLoc[5](Arg5: u64)
18StLoc[8](loc0: u64)
B3:
19MoveLoc[8](loc0: u64)
20StLoc[10](loc2: u64)
21CopyLoc[6](Arg6: u64)
22CopyLoc[12](loc4: &mut Position)
23ImmBorrowField[26](Position.tokens_owed_b: u64)
24ReadRef
25Gt
26BrFalse(32)
B4:
27CopyLoc[12](loc4: &mut Position)
28ImmBorrowField[26](Position.tokens_owed_b: u64)
29ReadRef
30StLoc[9](loc1: u64)
31Branch(34)
B5:
32MoveLoc[6](Arg6: u64)
33StLoc[9](loc1: u64)
B6:
34MoveLoc[9](loc1: u64)
35StLoc[11](loc3: u64)
36CopyLoc[10](loc2: u64)
37LdU64(0)
38Gt
39BrFalse(48)
B7:
40CopyLoc[12](loc4: &mut Position)
41ImmBorrowField[25](Position.tokens_owed_a: u64)
42ReadRef
43CopyLoc[10](loc2: u64)
44Sub
45CopyLoc[12](loc4: &mut Position)
46MutBorrowField[25](Position.tokens_owed_a: u64)
47WriteRef
B8:
48CopyLoc[11](loc3: u64)
49LdU64(0)
50Gt
51BrFalse(61)
B9:
52CopyLoc[12](loc4: &mut Position)
53ImmBorrowField[26](Position.tokens_owed_b: u64)
54ReadRef
55CopyLoc[11](loc3: u64)
56Sub
57MoveLoc[12](loc4: &mut Position)
58MutBorrowField[26](Position.tokens_owed_b: u64)
59WriteRef
60Branch(63)
B10:
61MoveLoc[12](loc4: &mut Position)
62Pop
B11:
63MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
64FreezeRef
65Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
66MoveLoc[2](Arg2: address)
67MoveLoc[1](Arg1: address)
68MoveLoc[3](Arg3: I32)
69MoveLoc[4](Arg4: I32)
70CopyLoc[10](loc2: u64)
71CopyLoc[11](loc3: u64)
72Pack[20](CollectEventV2)
73Call event::emit<CollectEventV2>(CollectEventV2)
74MoveLoc[10](loc2: u64)
75MoveLoc[11](loc3: u64)
76Ret
}
public(friend) collect_protocol_fee<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) collect_protocol_fee_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: u64, Arg3: address, Arg4: &mut TxContext): Coin<Ty0> * Coin<Ty1> {
L5: loc0: u64
L6: loc1: u64
L7: loc2: u64
L8: loc3: u64
L9: loc4: Coin<Ty0>
L10: loc5: Coin<Ty1>
B0:
0CopyLoc[1](Arg1: u64)
1CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
2ImmBorrowFieldGeneric[11](Pool.protocol_fees_a: u64)
3ReadRef
4Gt
5BrFalse(11)
B1:
6CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
7ImmBorrowFieldGeneric[11](Pool.protocol_fees_a: u64)
8ReadRef
9StLoc[5](loc0: u64)
10Branch(13)
B2:
11MoveLoc[1](Arg1: u64)
12StLoc[5](loc0: u64)
B3:
13MoveLoc[5](loc0: u64)
14StLoc[7](loc2: u64)
15CopyLoc[2](Arg2: u64)
16CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
17ImmBorrowFieldGeneric[12](Pool.protocol_fees_b: u64)
18ReadRef
19Gt
20BrFalse(26)
B4:
21CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
22ImmBorrowFieldGeneric[12](Pool.protocol_fees_b: u64)
23ReadRef
24StLoc[6](loc1: u64)
25Branch(28)
B5:
26MoveLoc[2](Arg2: u64)
27StLoc[6](loc1: u64)
B6:
28MoveLoc[6](loc1: u64)
29StLoc[8](loc3: u64)
30CopyLoc[7](loc2: u64)
31LdU64(0)
32Gt
33BrFalse(42)
B7:
34CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
35ImmBorrowFieldGeneric[11](Pool.protocol_fees_a: u64)
36ReadRef
37CopyLoc[7](loc2: u64)
38Sub
39CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
40MutBorrowFieldGeneric[11](Pool.protocol_fees_a: u64)
41WriteRef
B8:
42CopyLoc[8](loc3: u64)
43LdU64(0)
44Gt
45BrFalse(54)
B9:
46CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
47ImmBorrowFieldGeneric[12](Pool.protocol_fees_b: u64)
48ReadRef
49CopyLoc[8](loc3: u64)
50Sub
51CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
52MutBorrowFieldGeneric[12](Pool.protocol_fees_b: u64)
53WriteRef
B10:
54CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
55CopyLoc[7](loc2: u64)
56CopyLoc[8](loc3: u64)
57MoveLoc[4](Arg4: &mut TxContext)
58Call split_out_and_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64, u64, &mut TxContext): Coin<Ty0> * Coin<Ty1>
59StLoc[10](loc5: Coin<Ty1>)
60StLoc[9](loc4: Coin<Ty0>)
61MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
62FreezeRef
63Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
64MoveLoc[3](Arg3: address)
65MoveLoc[7](loc2: u64)
66MoveLoc[8](loc3: u64)
67Pack[18](CollectProtocolFeeEvent)
68Call event::emit<CollectProtocolFeeEvent>(CollectProtocolFeeEvent)
69MoveLoc[9](loc4: Coin<Ty0>)
70MoveLoc[10](loc5: Coin<Ty1>)
71Ret
}
public(friend) update_pool_fee_protocol<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u32) {
B0:
0CopyLoc[1](Arg1: u32)
1CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
2MutBorrowFieldGeneric[10](Pool.fee_protocol: u32)
3WriteRef
4MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
5FreezeRef
6Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
7MoveLoc[1](Arg1: u32)
8Pack[16](UpdatePoolFeeProtocolEvent)
9Call event::emit<UpdatePoolFeeProtocolEvent>(UpdatePoolFeeProtocolEvent)
10Ret
}
public(friend) init_reward<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: address, Arg3: &mut TxContext): PoolRewardVault<Ty3> {
L4: loc0: PoolRewardVault<Ty3>
B0:
0CopyLoc[1](Arg1: u64)
1LdConst[3](u64: 3)
2Lt
3BrFalse(5)
B1:
4Branch(11)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6Pop
7MoveLoc[3](Arg3: &mut TxContext)
8Pop
9LdConst[10](u64: 13)
10Abort
B3:
11CopyLoc[1](Arg1: u64)
12CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
13ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
14VecLen(112)
15Eq
16BrFalse(18)
B4:
17Branch(24)
B5:
18MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
19Pop
20MoveLoc[3](Arg3: &mut TxContext)
21Pop
22LdConst[10](u64: 13)
23Abort
B6:
24CopyLoc[3](Arg3: &mut TxContext)
25Call object::new(&mut TxContext): UID
26Call balance::zero<Ty3>(): Balance<Ty3>
27PackGeneric[3](PoolRewardVault<Ty3>)
28StLoc[4](loc0: PoolRewardVault<Ty3>)
29CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
30MutBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
31MoveLoc[3](Arg3: &mut TxContext)
32Call object::new(&mut TxContext): UID
33ImmBorrowLoc[4](loc0: PoolRewardVault<Ty3>)
34Call object::id_address<PoolRewardVault<Ty3>>(&PoolRewardVault<Ty3>): address
35Call type_name::get<Ty3>(): TypeName
36Call type_name::into_string(TypeName): String
37Call string::from_ascii(String): String
38LdU128(0)
39LdU128(0)
40CopyLoc[2](Arg2: address)
41Pack[6](PoolRewardInfo)
42CopyLoc[1](Arg1: u64)
43Call vector::insert<PoolRewardInfo>(&mut vector<PoolRewardInfo>, PoolRewardInfo, u64)
44MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
45FreezeRef
46Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
47MoveLoc[1](Arg1: u64)
48ImmBorrowLoc[4](loc0: PoolRewardVault<Ty3>)
49Call object::id_address<PoolRewardVault<Ty3>>(&PoolRewardVault<Ty3>): address
50MoveLoc[2](Arg2: address)
51Pack[22](InitRewardEvent)
52Call event::emit<InitRewardEvent>(InitRewardEvent)
53MoveLoc[4](loc0: PoolRewardVault<Ty3>)
54Ret
}
public(friend) reset_reward<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: &mut TxContext) {
L3: loc0: &mut PoolRewardInfo
B0:
0CopyLoc[1](Arg1: u64)
1LdConst[3](u64: 3)
2Lt
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6Pop
7LdConst[10](u64: 13)
8Abort
B3:
9MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
10MutBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
11MoveLoc[1](Arg1: u64)
12VecMutBorrow(112)
13StLoc[3](loc0: &mut PoolRewardInfo)
14LdU128(0)
15CopyLoc[3](loc0: &mut PoolRewardInfo)
16MutBorrowField[28](PoolRewardInfo.growth_global: u128)
17WriteRef
18LdU128(0)
19MoveLoc[3](loc0: &mut PoolRewardInfo)
20MutBorrowField[29](PoolRewardInfo.emissions_per_second: u128)
21WriteRef
22Ret
}
public(friend) update_reward_manager<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: address, Arg3: &mut TxContext) {
L4: loc0: &mut PoolRewardInfo
B0:
0CopyLoc[1](Arg1: u64)
1LdConst[3](u64: 3)
2Lt
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6Pop
7LdConst[10](u64: 13)
8Abort
B3:
9CopyLoc[1](Arg1: u64)
10CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
11ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
12VecLen(112)
13Lt
14BrFalse(16)
B4:
15Branch(20)
B5:
16MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
17Pop
18LdConst[10](u64: 13)
19Abort
B6:
20CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
21MutBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
22CopyLoc[1](Arg1: u64)
23VecMutBorrow(112)
24StLoc[4](loc0: &mut PoolRewardInfo)
25CopyLoc[2](Arg2: address)
26MoveLoc[4](loc0: &mut PoolRewardInfo)
27MutBorrowField[30](PoolRewardInfo.manager: address)
28WriteRef
29MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
30FreezeRef
31Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
32MoveLoc[1](Arg1: u64)
33MoveLoc[2](Arg2: address)
34Pack[23](UpdateRewardManagerEvent)
35Call event::emit<UpdateRewardManagerEvent>(UpdateRewardManagerEvent)
36Ret
}
public(friend) update_reward_emissions<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: u128, Arg3: &Clock, Arg4: &mut TxContext) {
L5: loc0: ID
L6: loc1: &mut PoolRewardInfo
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MoveLoc[3](Arg3: &Clock)
2Call clock::timestamp_ms(&Clock): u64
3Call next_pool_reward_infos<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64): vector<u128>
4Pop
5CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6FreezeRef
7Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
8StLoc[5](loc0: ID)
9CopyLoc[1](Arg1: u64)
10CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
11ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
12VecLen(112)
13Lt
14BrFalse(16)
B1:
15Branch(20)
B2:
16MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
17Pop
18LdConst[10](u64: 13)
19Abort
B3:
20MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
21MutBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
22CopyLoc[1](Arg1: u64)
23VecMutBorrow(112)
24StLoc[6](loc1: &mut PoolRewardInfo)
25CopyLoc[2](Arg2: u128)
26LdConst[26](u8: 64)
27Shl
28CopyLoc[6](loc1: &mut PoolRewardInfo)
29MutBorrowField[29](PoolRewardInfo.emissions_per_second: u128)
30WriteRef
31MoveLoc[5](loc0: ID)
32MoveLoc[1](Arg1: u64)
33CopyLoc[6](loc1: &mut PoolRewardInfo)
34ImmBorrowField[31](PoolRewardInfo.vault: address)
35ReadRef
36MoveLoc[6](loc1: &mut PoolRewardInfo)
37ImmBorrowField[30](PoolRewardInfo.manager: address)
38ReadRef
39MoveLoc[2](Arg2: u128)
40Pack[24](UpdateRewardEmissionsEvent)
41Call event::emit<UpdateRewardEmissionsEvent>(UpdateRewardEmissionsEvent)
42Ret
}
public(friend) add_reward<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut PoolRewardVault<Ty3>, Arg2: u64, Arg3: Coin<Ty3>, Arg4: u64, Arg5: &Clock, Arg6: &mut TxContext) {
L7: loc0: Coin<Ty3>
L8: loc1: &PoolRewardInfo
B0:
0CopyLoc[2](Arg2: u64)
1CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
2ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
3VecLen(112)
4Lt
5BrFalse(7)
B1:
6Branch(17)
B2:
7MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
8Pop
9MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
10Pop
11MoveLoc[6](Arg6: &mut TxContext)
12Pop
13MoveLoc[5](Arg5: &Clock)
14Pop
15LdConst[10](u64: 13)
16Abort
B3:
17CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
18MoveLoc[5](Arg5: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20Call next_pool_reward_infos<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64): vector<u128>
21Pop
22CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
23ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
24CopyLoc[2](Arg2: u64)
25VecImmBorrow(112)
26StLoc[8](loc1: &PoolRewardInfo)
27CopyLoc[8](loc1: &PoolRewardInfo)
28ImmBorrowField[31](PoolRewardInfo.vault: address)
29ReadRef
30CopyLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
31FreezeRef
32Call object::id_address<PoolRewardVault<Ty3>>(&PoolRewardVault<Ty3>): address
33Eq
34BrFalse(36)
B4:
35Branch(46)
B5:
36MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
37Pop
38MoveLoc[8](loc1: &PoolRewardInfo)
39Pop
40MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
41Pop
42MoveLoc[6](Arg6: &mut TxContext)
43Pop
44LdConst[11](u64: 14)
45Abort
B6:
46MutBorrowLoc[3](Arg3: Coin<Ty3>)
47CopyLoc[4](Arg4: u64)
48CopyLoc[6](Arg6: &mut TxContext)
49Call coin::split<Ty3>(&mut Coin<Ty3>, u64, &mut TxContext): Coin<Ty3>
50StLoc[7](loc0: Coin<Ty3>)
51MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
52MutBorrowFieldGeneric[14](PoolRewardVault.coin: Balance<Ty3>)
53MoveLoc[7](loc0: Coin<Ty3>)
54Call coin::into_balance<Ty3>(Coin<Ty3>): Balance<Ty3>
55Call balance::join<Ty3>(&mut Balance<Ty3>, Balance<Ty3>): u64
56Pop
57ImmBorrowLoc[3](Arg3: Coin<Ty3>)
58Call coin::value<Ty3>(&Coin<Ty3>): u64
59LdU64(0)
60Eq
61BrFalse(67)
B7:
62MoveLoc[6](Arg6: &mut TxContext)
63Pop
64MoveLoc[3](Arg3: Coin<Ty3>)
65Call coin::destroy_zero<Ty3>(Coin<Ty3>)
66Branch(72)
B8:
67MoveLoc[3](Arg3: Coin<Ty3>)
68MoveLoc[6](Arg6: &mut TxContext)
69FreezeRef
70Call tx_context::sender(&TxContext): address
71Call transfer::public_transfer<Coin<Ty3>>(Coin<Ty3>, address)
B9:
72MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
73FreezeRef
74Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
75MoveLoc[2](Arg2: u64)
76CopyLoc[8](loc1: &PoolRewardInfo)
77ImmBorrowField[31](PoolRewardInfo.vault: address)
78ReadRef
79MoveLoc[8](loc1: &PoolRewardInfo)
80ImmBorrowField[30](PoolRewardInfo.manager: address)
81ReadRef
82MoveLoc[4](Arg4: u64)
83Pack[25](AddRewardEvent)
84Call event::emit<AddRewardEvent>(AddRewardEvent)
85Ret
}
public(friend) remove_reward<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut PoolRewardVault<Ty3>, Arg2: u64, Arg3: u64, Arg4: address, Arg5: &Clock, Arg6: &mut TxContext) {
L7: loc0: &PoolRewardInfo
B0:
0CopyLoc[2](Arg2: u64)
1CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
2ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
3VecLen(112)
4Lt
5BrFalse(7)
B1:
6Branch(17)
B2:
7MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
8Pop
9MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
10Pop
11MoveLoc[6](Arg6: &mut TxContext)
12Pop
13MoveLoc[5](Arg5: &Clock)
14Pop
15LdConst[10](u64: 13)
16Abort
B3:
17CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
18MoveLoc[5](Arg5: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20Call next_pool_reward_infos<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64): vector<u128>
21Pop
22CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
23ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
24CopyLoc[2](Arg2: u64)
25VecImmBorrow(112)
26StLoc[7](loc0: &PoolRewardInfo)
27CopyLoc[7](loc0: &PoolRewardInfo)
28ImmBorrowField[31](PoolRewardInfo.vault: address)
29ReadRef
30CopyLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
31FreezeRef
32Call object::id_address<PoolRewardVault<Ty3>>(&PoolRewardVault<Ty3>): address
33Eq
34BrFalse(36)
B4:
35Branch(46)
B5:
36MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
37Pop
38MoveLoc[7](loc0: &PoolRewardInfo)
39Pop
40MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
41Pop
42MoveLoc[6](Arg6: &mut TxContext)
43Pop
44LdConst[11](u64: 14)
45Abort
B6:
46CopyLoc[3](Arg3: u64)
47CopyLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
48ImmBorrowFieldGeneric[14](PoolRewardVault.coin: Balance<Ty3>)
49Call balance::value<Ty3>(&Balance<Ty3>): u64
50Le
51BrFalse(53)
B7:
52Branch(63)
B8:
53MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
54Pop
55MoveLoc[7](loc0: &PoolRewardInfo)
56Pop
57MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
58Pop
59MoveLoc[6](Arg6: &mut TxContext)
60Pop
61LdConst[13](u64: 16)
62Abort
B9:
63MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
64MutBorrowFieldGeneric[14](PoolRewardVault.coin: Balance<Ty3>)
65CopyLoc[3](Arg3: u64)
66Call balance::split<Ty3>(&mut Balance<Ty3>, u64): Balance<Ty3>
67MoveLoc[6](Arg6: &mut TxContext)
68Call coin::from_balance<Ty3>(Balance<Ty3>, &mut TxContext): Coin<Ty3>
69CopyLoc[4](Arg4: address)
70Call transfer::public_transfer<Coin<Ty3>>(Coin<Ty3>, address)
71MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
72FreezeRef
73Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
74MoveLoc[2](Arg2: u64)
75CopyLoc[7](loc0: &PoolRewardInfo)
76ImmBorrowField[31](PoolRewardInfo.vault: address)
77ReadRef
78MoveLoc[7](loc0: &PoolRewardInfo)
79ImmBorrowField[30](PoolRewardInfo.manager: address)
80ReadRef
81MoveLoc[3](Arg3: u64)
82MoveLoc[4](Arg4: address)
83Pack[26](RemoveRewardEvent)
84Call event::emit<RemoveRewardEvent>(RemoveRewardEvent)
85Ret
}
public(friend) collect_reward<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut PoolRewardVault<Ty3>, Arg2: address, Arg3: I32, Arg4: I32, Arg5: u64, Arg6: u64, Arg7: &mut TxContext): u64 {
B0:
0LdU64(0)
1Abort
}
public(friend) collect_reward_v2<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut PoolRewardVault<Ty3>, Arg2: address, Arg3: address, Arg4: I32, Arg5: I32, Arg6: u64, Arg7: u64, Arg8: &mut TxContext): u64 {
B0:
0LdU64(0)
1Abort
}
public(friend) collect_reward_with_return_<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut PoolRewardVault<Ty3>, Arg2: address, Arg3: address, Arg4: I32, Arg5: I32, Arg6: u64, Arg7: u64, Arg8: &mut TxContext): Coin<Ty3> {
L9: loc0: u64
L10: loc1: u64
L11: loc2: Coin<Ty3>
L12: loc3: &mut Position
L13: loc4: &mut PositionRewardInfo
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
2CopyLoc[7](Arg7: u64)
3VecImmBorrow(112)
4ImmBorrowField[31](PoolRewardInfo.vault: address)
5ReadRef
6CopyLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
7FreezeRef
8Call object::id_address<PoolRewardVault<Ty3>>(&PoolRewardVault<Ty3>): address
9Eq
10BrFalse(12)
B1:
11Branch(20)
B2:
12MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
13Pop
14MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
15Pop
16MoveLoc[8](Arg8: &mut TxContext)
17Pop
18LdConst[11](u64: 14)
19Abort
B3:
20CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
21CopyLoc[3](Arg3: address)
22CopyLoc[4](Arg4: I32)
23CopyLoc[5](Arg5: I32)
24Call get_position_mut<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32): &mut Position
25StLoc[12](loc3: &mut Position)
26CopyLoc[7](Arg7: u64)
27CopyLoc[12](loc3: &mut Position)
28ImmBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
29VecLen(162)
30Lt
31BrFalse(33)
B4:
32Branch(43)
B5:
33MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
34Pop
35MoveLoc[12](loc3: &mut Position)
36Pop
37MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
38Pop
39MoveLoc[8](Arg8: &mut TxContext)
40Pop
41LdConst[10](u64: 13)
42Abort
B6:
43MoveLoc[12](loc3: &mut Position)
44MutBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
45CopyLoc[7](Arg7: u64)
46VecMutBorrow(162)
47StLoc[13](loc4: &mut PositionRewardInfo)
48CopyLoc[6](Arg6: u64)
49CopyLoc[13](loc4: &mut PositionRewardInfo)
50ImmBorrowField[34](PositionRewardInfo.amount_owed: u64)
51ReadRef
52Gt
53BrFalse(59)
B7:
54CopyLoc[13](loc4: &mut PositionRewardInfo)
55ImmBorrowField[34](PositionRewardInfo.amount_owed: u64)
56ReadRef
57StLoc[9](loc0: u64)
58Branch(61)
B8:
59MoveLoc[6](Arg6: u64)
60StLoc[9](loc0: u64)
B9:
61MoveLoc[9](loc0: u64)
62StLoc[10](loc1: u64)
63CopyLoc[10](loc1: u64)
64LdU64(0)
65Gt
66BrFalse(76)
B10:
67CopyLoc[13](loc4: &mut PositionRewardInfo)
68ImmBorrowField[34](PositionRewardInfo.amount_owed: u64)
69ReadRef
70CopyLoc[10](loc1: u64)
71Sub
72MoveLoc[13](loc4: &mut PositionRewardInfo)
73MutBorrowField[34](PositionRewardInfo.amount_owed: u64)
74WriteRef
75Branch(78)
B11:
76MoveLoc[13](loc4: &mut PositionRewardInfo)
77Pop
B12:
78CopyLoc[10](loc1: u64)
79CopyLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
80ImmBorrowFieldGeneric[14](PoolRewardVault.coin: Balance<Ty3>)
81Call balance::value<Ty3>(&Balance<Ty3>): u64
82Le
83BrFalse(85)
B13:
84Branch(93)
B14:
85MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
86Pop
87MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
88Pop
89MoveLoc[8](Arg8: &mut TxContext)
90Pop
91LdConst[0](u64: 18)
92Abort
B15:
93CopyLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
94MutBorrowFieldGeneric[14](PoolRewardVault.coin: Balance<Ty3>)
95CopyLoc[10](loc1: u64)
96Call balance::split<Ty3>(&mut Balance<Ty3>, u64): Balance<Ty3>
97MoveLoc[8](Arg8: &mut TxContext)
98Call coin::from_balance<Ty3>(Balance<Ty3>, &mut TxContext): Coin<Ty3>
99StLoc[11](loc2: Coin<Ty3>)
100MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
101FreezeRef
102Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
103MoveLoc[2](Arg2: address)
104MoveLoc[3](Arg3: address)
105MoveLoc[4](Arg4: I32)
106MoveLoc[5](Arg5: I32)
107MoveLoc[10](loc1: u64)
108MoveLoc[1](Arg1: &mut PoolRewardVault<Ty3>)
109FreezeRef
110Call object::id<PoolRewardVault<Ty3>>(&PoolRewardVault<Ty3>): ID
111Call type_name::get<Ty3>(): TypeName
112MoveLoc[7](Arg7: u64)
113Pack[21](CollectRewardEventV2)
114Call event::emit<CollectRewardEventV2>(CollectRewardEventV2)
115MoveLoc[11](loc2: Coin<Ty3>)
116Ret
}
next_pool_reward_infos<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64): vector<u128> {
L2: loc0: bool
L3: loc1: u64
L4: loc2: vector<u128>
L5: loc3: u64
L6: loc4: u64
L7: loc5: u64
L8: loc6: u128
L9: loc7: &mut PoolRewardInfo
L10: loc8: u64
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[15](Pool.reward_last_updated_time_ms: u64)
2ReadRef
3StLoc[3](loc1: u64)
4CopyLoc[1](Arg1: u64)
5CopyLoc[3](loc1: u64)
6Ge
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
10Pop
11LdConst[12](u64: 15)
12Abort
B3:
13VecPack(72, 0)
14StLoc[4](loc2: vector<u128>)
15CopyLoc[1](Arg1: u64)
16MoveLoc[3](loc1: u64)
17Sub
18LdU64(1000)
19Div
20StLoc[10](loc8: u64)
21CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
22ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
23VecLen(112)
24StLoc[7](loc5: u64)
25LdU64(0)
26StLoc[5](loc3: u64)
B4:
27CopyLoc[5](loc3: u64)
28CopyLoc[7](loc5: u64)
29Lt
30BrFalse(88)
B5:
31Branch(32)
B6:
32CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
33MutBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
34CopyLoc[5](loc3: u64)
35VecMutBorrow(112)
36StLoc[9](loc7: &mut PoolRewardInfo)
37CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
38ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
39ReadRef
40LdU128(0)
41Eq
42BrFalse(46)
B7:
43LdTrue
44StLoc[2](loc0: bool)
45Branch(50)
B8:
46CopyLoc[10](loc8: u64)
47LdU64(0)
48Eq
49StLoc[2](loc0: bool)
B9:
50MoveLoc[2](loc0: bool)
51BrFalse(59)
B10:
52MutBorrowLoc[4](loc2: vector<u128>)
53MoveLoc[9](loc7: &mut PoolRewardInfo)
54ImmBorrowField[28](PoolRewardInfo.growth_global: u128)
55ReadRef
56CopyLoc[5](loc3: u64)
57Call vector::insert<u128>(&mut vector<u128>, u128, u64)
58Branch(83)
B11:
59CopyLoc[10](loc8: u64)
60CastU128
61CopyLoc[9](loc7: &mut PoolRewardInfo)
62ImmBorrowField[29](PoolRewardInfo.emissions_per_second: u128)
63ReadRef
64CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
65ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
66ReadRef
67Call full_math_u128::mul_div_floor(u128, u128, u128): u128
68StLoc[8](loc6: u128)
69CopyLoc[9](loc7: &mut PoolRewardInfo)
70ImmBorrowField[28](PoolRewardInfo.growth_global: u128)
71ReadRef
72MoveLoc[8](loc6: u128)
73Call math_u128::wrapping_add(u128, u128): u128
74CopyLoc[9](loc7: &mut PoolRewardInfo)
75MutBorrowField[28](PoolRewardInfo.growth_global: u128)
76WriteRef
77MutBorrowLoc[4](loc2: vector<u128>)
78MoveLoc[9](loc7: &mut PoolRewardInfo)
79ImmBorrowField[28](PoolRewardInfo.growth_global: u128)
80ReadRef
81CopyLoc[5](loc3: u64)
82Call vector::insert<u128>(&mut vector<u128>, u128, u64)
B12:
83MoveLoc[5](loc3: u64)
84LdU64(1)
85Add
86StLoc[5](loc3: u64)
87Branch(27)
B13:
88ImmBorrowLoc[4](loc2: vector<u128>)
89VecLen(72)
90StLoc[6](loc4: u64)
B14:
91CopyLoc[6](loc4: u64)
92LdConst[3](u64: 3)
93Lt
94BrFalse(104)
B15:
95Branch(96)
B16:
96MutBorrowLoc[4](loc2: vector<u128>)
97LdU128(0)
98VecPushBack(72)
99MoveLoc[6](loc4: u64)
100LdU64(1)
101Add
102StLoc[6](loc4: u64)
103Branch(91)
B17:
104MoveLoc[1](Arg1: u64)
105MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
106MutBorrowFieldGeneric[15](Pool.reward_last_updated_time_ms: u64)
107WriteRef
108MoveLoc[4](loc2: vector<u128>)
109Ret
}
public next_initialized_tick_within_one_word<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: bool): I32 * bool {
L3: loc0: bool
L4: loc1: I32
L5: loc2: I32
L6: loc3: I32
L7: loc4: I32
L8: loc5: u8
L9: loc6: u8
L10: loc7: I32
L11: loc8: bool
L12: loc9: u256
L13: loc10: u256
L14: loc11: u256
L15: loc12: u256
L16: loc13: I32
L17: loc14: u256
L18: loc15: u256
L19: loc16: I32
L20: loc17: I32
B0:
0CopyLoc[1](Arg1: I32)
1LdConst[24](u32: 443636)
2Call i32::neg_from(u32): I32
3Call i32::gte(I32, I32): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
7Pop
8LdConst[4](u64: 5)
9Abort
B3:
10CopyLoc[1](Arg1: I32)
11LdConst[24](u32: 443636)
12Call i32::from(u32): I32
13Call i32::lte(I32, I32): bool
14BrFalse(16)
B4:
15Branch(20)
B5:
16MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
17Pop
18LdConst[4](u64: 5)
19Abort
B6:
20CopyLoc[1](Arg1: I32)
21CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
22ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
23ReadRef
24Call i32::from(u32): I32
25Call i32::div(I32, I32): I32
26StLoc[10](loc7: I32)
27CopyLoc[1](Arg1: I32)
28Call i32::zero(): I32
29Call i32::lt(I32, I32): bool
30BrFalse(41)
B7:
31MoveLoc[1](Arg1: I32)
32CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
33ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
34ReadRef
35Call i32::mod_euclidean(I32, u32): I32
36Call i32::zero(): I32
37Call i32::eq(I32, I32): bool
38Not
39StLoc[3](loc0: bool)
40Branch(43)
B8:
41LdFalse
42StLoc[3](loc0: bool)
B9:
43MoveLoc[3](loc0: bool)
44BrFalse(50)
B10:
45MoveLoc[10](loc7: I32)
46LdU32(1)
47Call i32::from(u32): I32
48Call i32::sub(I32, I32): I32
49StLoc[10](loc7: I32)
B11:
50MoveLoc[2](Arg2: bool)
51BrFalse(115)
B12:
52CopyLoc[10](loc7: I32)
53Call position_tick(I32): I32 * u8
54StLoc[8](loc5: u8)
55StLoc[19](loc16: I32)
56CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
57CopyLoc[19](loc16: I32)
58Call try_init_tick_word<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32)
59CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
60MoveLoc[19](loc16: I32)
61StLoc[4](loc1: I32)
62FreezeRef
63MoveLoc[4](loc1: I32)
64Call get_tick_word<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, I32): u256
65StLoc[17](loc14: u256)
66LdU256(1)
67CopyLoc[8](loc5: u8)
68Shl
69LdU256(1)
70Sub
71LdU256(1)
72CopyLoc[8](loc5: u8)
73Shl
74Add
75StLoc[12](loc9: u256)
76MoveLoc[17](loc14: u256)
77MoveLoc[12](loc9: u256)
78BitAnd
79StLoc[14](loc11: u256)
80CopyLoc[14](loc11: u256)
81LdU256(0)
82Neq
83StLoc[11](loc8: bool)
84CopyLoc[11](loc8: bool)
85BrFalse(101)
B13:
86MoveLoc[10](loc7: I32)
87MoveLoc[8](loc5: u8)
88MoveLoc[14](loc11: u256)
89Call math_bit::most_significant_bit(u256): u8
90Sub
91CastU32
92Call i32::from(u32): I32
93Call i32::sub(I32, I32): I32
94MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
95ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
96ReadRef
97Call i32::from(u32): I32
98Call i32::mul(I32, I32): I32
99StLoc[5](loc2: I32)
100Branch(112)
B14:
101MoveLoc[10](loc7: I32)
102MoveLoc[8](loc5: u8)
103CastU32
104Call i32::from(u32): I32
105Call i32::sub(I32, I32): I32
106MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
107ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
108ReadRef
109Call i32::from(u32): I32
110Call i32::mul(I32, I32): I32
111StLoc[5](loc2: I32)
B15:
112MoveLoc[5](loc2: I32)
113StLoc[16](loc13: I32)
114Branch(188)
B16:
115CopyLoc[10](loc7: I32)
116LdU32(1)
117Call i32::from(u32): I32
118Call i32::add(I32, I32): I32
119Call position_tick(I32): I32 * u8
120StLoc[9](loc6: u8)
121StLoc[20](loc17: I32)
122CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
123CopyLoc[20](loc17: I32)
124Call try_init_tick_word<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32)
125CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
126MoveLoc[20](loc17: I32)
127StLoc[6](loc3: I32)
128FreezeRef
129MoveLoc[6](loc3: I32)
130Call get_tick_word<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, I32): u256
131StLoc[18](loc15: u256)
132LdU256(1)
133CopyLoc[9](loc6: u8)
134Shl
135LdU256(1)
136Sub
137LdU256(115792089237316195423570985008687907853269984665640564039457584007913129639935)
138Xor
139StLoc[13](loc10: u256)
140MoveLoc[18](loc15: u256)
141MoveLoc[13](loc10: u256)
142BitAnd
143StLoc[15](loc12: u256)
144CopyLoc[15](loc12: u256)
145LdU256(0)
146Neq
147StLoc[11](loc8: bool)
148CopyLoc[11](loc8: bool)
149BrFalse(170)
B17:
150MoveLoc[10](loc7: I32)
151LdU32(1)
152Call i32::from(u32): I32
153Call i32::add(I32, I32): I32
154MoveLoc[15](loc12: u256)
155Call math_bit::least_significant_bit(u256): u8
156CastU32
157Call i32::from(u32): I32
158MoveLoc[9](loc6: u8)
159CastU32
160Call i32::from(u32): I32
161Call i32::sub(I32, I32): I32
162Call i32::add(I32, I32): I32
163MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
164ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
165ReadRef
166Call i32::from(u32): I32
167Call i32::mul(I32, I32): I32
168StLoc[7](loc4: I32)
169Branch(186)
B18:
170MoveLoc[10](loc7: I32)
171LdU32(1)
172Call i32::from(u32): I32
173Call i32::add(I32, I32): I32
174LdU8(255)
175MoveLoc[9](loc6: u8)
176Sub
177CastU32
178Call i32::from(u32): I32
179Call i32::add(I32, I32): I32
180MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
181ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
182ReadRef
183Call i32::from(u32): I32
184Call i32::mul(I32, I32): I32
185StLoc[7](loc4: I32)
B19:
186MoveLoc[7](loc4: I32)
187StLoc[16](loc13: I32)
B20:
188MoveLoc[16](loc13: I32)
189MoveLoc[11](loc8: bool)
190Ret
}
public position_tick(Arg0: I32): I32 * u8 {
L1: loc0: u8
L2: loc1: I32
B0:
0CopyLoc[0](Arg0: I32)
1LdU8(8)
2Call i32::shr(I32, u8): I32
3StLoc[2](loc1: I32)
4MoveLoc[0](Arg0: I32)
5LdU32(256)
6Call i32::mod_euclidean(I32, u32): I32
7Call i32::abs_u32(I32): u32
8CastU8
9StLoc[1](loc0: u8)
10MoveLoc[2](loc1: I32)
11MoveLoc[1](loc0: u8)
12Ret
}
try_init_tick_word<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32) {
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[17](Pool.tick_map: Table<I32, u256>)
2CopyLoc[1](Arg1: I32)
3Call table::contains<I32, u256>(&Table<I32, u256>, I32): bool
4Not
5BrFalse(12)
B1:
6MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
7MutBorrowFieldGeneric[17](Pool.tick_map: Table<I32, u256>)
8MoveLoc[1](Arg1: I32)
9LdU256(0)
10Call table::add<I32, u256>(&mut Table<I32, u256>, I32, u256)
11Branch(14)
B2:
12MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
13Pop
B3:
14Ret
}
get_tick_word<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: I32): u256 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[17](Pool.tick_map: Table<I32, u256>)
2MoveLoc[1](Arg1: I32)
3Call table::borrow<I32, u256>(&Table<I32, u256>, I32): &u256
4ReadRef
5Ret
}
get_tick_word_mut<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32): &mut u256 {
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MutBorrowFieldGeneric[17](Pool.tick_map: Table<I32, u256>)
2MoveLoc[1](Arg1: I32)
3Call table::borrow_mut<I32, u256>(&mut Table<I32, u256>, I32): &mut u256
4Ret
}
modify_position<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32, Arg4: I128, Arg5: &Clock, Arg6: &mut TxContext): I128 * I128 {
L7: loc0: I128
L8: loc1: I128
B0:
0CopyLoc[2](Arg2: I32)
1CopyLoc[3](Arg3: I32)
2Call check_ticks(I32, I32)
3CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
4MoveLoc[1](Arg1: address)
5CopyLoc[2](Arg2: I32)
6CopyLoc[3](Arg3: I32)
7CopyLoc[4](Arg4: I128)
8MoveLoc[5](Arg5: &Clock)
9MoveLoc[6](Arg6: &mut TxContext)
10Call update_position<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, I128, &Clock, &mut TxContext)
11Call i128::zero(): I128
12StLoc[7](loc0: I128)
13Call i128::zero(): I128
14StLoc[8](loc1: I128)
15CopyLoc[4](Arg4: I128)
16Call i128::zero(): I128
17Call i128::eq(I128, I128): bool
18Not
19BrFalse(77)
B1:
20CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
21ImmBorrowFieldGeneric[5](Pool.tick_current_index: I32)
22ReadRef
23CopyLoc[2](Arg2: I32)
24Call i32::lt(I32, I32): bool
25BrFalse(36)
B2:
26MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
27Pop
28MoveLoc[2](Arg2: I32)
29Call math_tick::sqrt_price_from_tick_index(I32): u128
30MoveLoc[3](Arg3: I32)
31Call math_tick::sqrt_price_from_tick_index(I32): u128
32MoveLoc[4](Arg4: I128)
33Call math_sqrt_price::get_amount_a_delta(u128, u128, I128): I128
34StLoc[7](loc0: I128)
35Branch(76)
B3:
36CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
37ImmBorrowFieldGeneric[5](Pool.tick_current_index: I32)
38ReadRef
39CopyLoc[3](Arg3: I32)
40Call i32::lt(I32, I32): bool
41BrFalse(67)
B4:
42CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
43ImmBorrowFieldGeneric[4](Pool.sqrt_price: u128)
44ReadRef
45MoveLoc[3](Arg3: I32)
46Call math_tick::sqrt_price_from_tick_index(I32): u128
47CopyLoc[4](Arg4: I128)
48Call math_sqrt_price::get_amount_a_delta(u128, u128, I128): I128
49StLoc[7](loc0: I128)
50MoveLoc[2](Arg2: I32)
51Call math_tick::sqrt_price_from_tick_index(I32): u128
52CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
53ImmBorrowFieldGeneric[4](Pool.sqrt_price: u128)
54ReadRef
55CopyLoc[4](Arg4: I128)
56Call math_sqrt_price::get_amount_b_delta(u128, u128, I128): I128
57StLoc[8](loc1: I128)
58CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
59ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
60ReadRef
61MoveLoc[4](Arg4: I128)
62Call math_liquidity::add_delta(u128, I128): u128
63MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
64MutBorrowFieldGeneric[8](Pool.liquidity: u128)
65WriteRef
66Branch(76)
B5:
67MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
68Pop
69MoveLoc[2](Arg2: I32)
70Call math_tick::sqrt_price_from_tick_index(I32): u128
71MoveLoc[3](Arg3: I32)
72Call math_tick::sqrt_price_from_tick_index(I32): u128
73MoveLoc[4](Arg4: I128)
74Call math_sqrt_price::get_amount_b_delta(u128, u128, I128): I128
75StLoc[8](loc1: I128)
B6:
76Branch(79)
B7:
77MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
78Pop
B8:
79MoveLoc[7](loc0: I128)
80MoveLoc[8](loc1: I128)
81Ret
}
try_init_position<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32, Arg4: &mut TxContext) {
L5: loc0: address
L6: loc1: I32
L7: loc2: I32
L8: loc3: u64
L9: loc4: String
L10: loc5: vector<PositionRewardInfo>
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: address)
2MoveLoc[2](Arg2: I32)
3MoveLoc[3](Arg3: I32)
4StLoc[7](loc2: I32)
5StLoc[6](loc1: I32)
6StLoc[5](loc0: address)
7FreezeRef
8MoveLoc[5](loc0: address)
9MoveLoc[6](loc1: I32)
10MoveLoc[7](loc2: I32)
11Call get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String
12StLoc[9](loc4: String)
13CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
14ImmBorrowFieldGeneric[18](Pool.id: UID)
15CopyLoc[9](loc4: String)
16Call dynamic_object_field::exists_<String>(&UID, String): bool
17Not
18BrFalse(52)
B1:
19VecPack(162, 0)
20StLoc[10](loc5: vector<PositionRewardInfo>)
21LdU64(0)
22StLoc[8](loc3: u64)
B2:
23CopyLoc[8](loc3: u64)
24LdConst[3](u64: 3)
25Lt
26BrFalse(38)
B3:
27Branch(28)
B4:
28MutBorrowLoc[10](loc5: vector<PositionRewardInfo>)
29LdU128(0)
30LdU64(0)
31Pack[3](PositionRewardInfo)
32VecPushBack(162)
33MoveLoc[8](loc3: u64)
34LdU64(1)
35Add
36StLoc[8](loc3: u64)
37Branch(23)
B5:
38MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
39MutBorrowFieldGeneric[18](Pool.id: UID)
40MoveLoc[9](loc4: String)
41MoveLoc[4](Arg4: &mut TxContext)
42Call object::new(&mut TxContext): UID
43LdU128(0)
44LdU128(0)
45LdU128(0)
46LdU64(0)
47LdU64(0)
48MoveLoc[10](loc5: vector<PositionRewardInfo>)
49Pack[4](Position)
50Call dynamic_object_field::add<String, Position>(&mut UID, String, Position)
51Branch(56)
B6:
52MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
53Pop
54MoveLoc[4](Arg4: &mut TxContext)
55Pop
B7:
56Ret
}
update_position<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32, Arg4: I128, Arg5: &Clock, Arg6: &mut TxContext) {
L7: loc0: address
L8: loc1: I32
L9: loc2: I32
L10: loc3: u128
L11: loc4: u128
L12: loc5: bool
L13: loc6: bool
L14: loc7: String
L15: loc8: vector<u128>
L16: loc9: vector<u128>
L17: loc10: I32
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[5](Pool.tick_current_index: I32)
2ReadRef
3StLoc[17](loc10: I32)
4LdFalse
5StLoc[12](loc5: bool)
6LdFalse
7StLoc[13](loc6: bool)
8CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
9MoveLoc[5](Arg5: &Clock)
10Call clock::timestamp_ms(&Clock): u64
11Call next_pool_reward_infos<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64): vector<u128>
12StLoc[15](loc8: vector<u128>)
13CopyLoc[4](Arg4: I128)
14Call i128::zero(): I128
15Call i128::eq(I128, I128): bool
16Not
17BrFalse(48)
B1:
18CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
19CopyLoc[2](Arg2: I32)
20CopyLoc[17](loc10: I32)
21CopyLoc[4](Arg4: I128)
22LdFalse
23CopyLoc[15](loc8: vector<u128>)
24CopyLoc[6](Arg6: &mut TxContext)
25Call update_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, I32, I128, bool, vector<u128>, &mut TxContext): bool
26StLoc[12](loc5: bool)
27CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
28CopyLoc[3](Arg3: I32)
29CopyLoc[17](loc10: I32)
30CopyLoc[4](Arg4: I128)
31LdTrue
32MoveLoc[15](loc8: vector<u128>)
33CopyLoc[6](Arg6: &mut TxContext)
34Call update_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, I32, I128, bool, vector<u128>, &mut TxContext): bool
35StLoc[13](loc6: bool)
36CopyLoc[12](loc5: bool)
37BrFalse(42)
B2:
38CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
39CopyLoc[2](Arg2: I32)
40CopyLoc[6](Arg6: &mut TxContext)
41Call flip_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, &mut TxContext)
B3:
42CopyLoc[13](loc6: bool)
43BrFalse(48)
B4:
44CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
45CopyLoc[3](Arg3: I32)
46CopyLoc[6](Arg6: &mut TxContext)
47Call flip_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, &mut TxContext)
B5:
48CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
49CopyLoc[2](Arg2: I32)
50CopyLoc[3](Arg3: I32)
51CopyLoc[17](loc10: I32)
52CopyLoc[6](Arg6: &mut TxContext)
53Call next_fee_growth_inside<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, I32, I32, &mut TxContext): u128 * u128
54StLoc[11](loc4: u128)
55StLoc[10](loc3: u128)
56CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
57CopyLoc[2](Arg2: I32)
58CopyLoc[3](Arg3: I32)
59MoveLoc[17](loc10: I32)
60CopyLoc[6](Arg6: &mut TxContext)
61Call next_reward_growths_inside<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, I32, I32, &mut TxContext): vector<u128>
62StLoc[16](loc9: vector<u128>)
63CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
64MoveLoc[1](Arg1: address)
65CopyLoc[2](Arg2: I32)
66CopyLoc[3](Arg3: I32)
67StLoc[9](loc2: I32)
68StLoc[8](loc1: I32)
69StLoc[7](loc0: address)
70FreezeRef
71MoveLoc[7](loc0: address)
72MoveLoc[8](loc1: I32)
73MoveLoc[9](loc2: I32)
74Call get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String
75StLoc[14](loc7: String)
76CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
77MoveLoc[14](loc7: String)
78CopyLoc[4](Arg4: I128)
79MoveLoc[10](loc3: u128)
80MoveLoc[11](loc4: u128)
81MoveLoc[16](loc9: vector<u128>)
82CopyLoc[6](Arg6: &mut TxContext)
83Call update_position_metadata<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, String, I128, u128, u128, vector<u128>, &mut TxContext)
84MoveLoc[4](Arg4: I128)
85Call i128::is_neg(I128): bool
86BrFalse(105)
B6:
87MoveLoc[12](loc5: bool)
88BrFalse(93)
B7:
89CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
90MoveLoc[2](Arg2: I32)
91CopyLoc[6](Arg6: &mut TxContext)
92Call clear_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, &mut TxContext)
B8:
93MoveLoc[13](loc6: bool)
94BrFalse(100)
B9:
95MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
96MoveLoc[3](Arg3: I32)
97MoveLoc[6](Arg6: &mut TxContext)
98Call clear_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, &mut TxContext)
99Branch(104)
B10:
100MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
101Pop
102MoveLoc[6](Arg6: &mut TxContext)
103Pop
B11:
104Branch(109)
B12:
105MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
106Pop
107MoveLoc[6](Arg6: &mut TxContext)
108Pop
B13:
109Ret
}
check_ticks(Arg0: I32, Arg1: I32) {
B0:
0CopyLoc[0](Arg0: I32)
1CopyLoc[1](Arg1: I32)
2Call i32::lt(I32, I32): bool
3BrFalse(5)
B1:
4Branch(7)
B2:
5LdConst[4](u64: 5)
6Abort
B3:
7MoveLoc[0](Arg0: I32)
8LdConst[24](u32: 443636)
9Call i32::neg_from(u32): I32
10Call i32::gte(I32, I32): bool
11BrFalse(13)
B4:
12Branch(15)
B5:
13LdConst[4](u64: 5)
14Abort
B6:
15MoveLoc[1](Arg1: I32)
16LdConst[24](u32: 443636)
17Call i32::from(u32): I32
18Call i32::lte(I32, I32): bool
19BrFalse(21)
B7:
20Branch(23)
B8:
21LdConst[4](u64: 5)
22Abort
B9:
23Ret
}
update_tick<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: I32, Arg3: I128, Arg4: bool, Arg5: vector<u128>, Arg6: &mut TxContext): bool {
L7: loc0: I128
L8: loc1: u128
L9: loc2: u128
L10: loc3: bool
L11: loc4: u128
L12: loc5: u128
L13: loc6: u128
L14: loc7: &mut Tick
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
2ReadRef
3StLoc[8](loc1: u128)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
5ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
6ReadRef
7StLoc[9](loc2: u128)
8CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
9ImmBorrowFieldGeneric[19](Pool.max_liquidity_per_tick: u128)
10ReadRef
11StLoc[13](loc6: u128)
12CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
13ImmBorrowFieldGeneric[18](Pool.id: UID)
14CopyLoc[1](Arg1: I32)
15Call dynamic_field::exists_<I32>(&UID, I32): bool
16Not
17BrFalse(24)
B1:
18MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
19CopyLoc[1](Arg1: I32)
20MoveLoc[6](Arg6: &mut TxContext)
21Call init_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, &mut TxContext): &mut Tick
22StLoc[14](loc7: &mut Tick)
23Branch(31)
B2:
24MoveLoc[6](Arg6: &mut TxContext)
25Pop
26MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
27MutBorrowFieldGeneric[18](Pool.id: UID)
28CopyLoc[1](Arg1: I32)
29Call dynamic_field::borrow_mut<I32, Tick>(&mut UID, I32): &mut Tick
30StLoc[14](loc7: &mut Tick)
B3:
31CopyLoc[14](loc7: &mut Tick)
32ImmBorrowField[40](Tick.liquidity_gross: u128)
33ReadRef
34StLoc[12](loc5: u128)
35CopyLoc[12](loc5: u128)
36CopyLoc[3](Arg3: I128)
37Call math_liquidity::add_delta(u128, I128): u128
38StLoc[11](loc4: u128)
39CopyLoc[11](loc4: u128)
40MoveLoc[13](loc6: u128)
41Le
42BrFalse(44)
B4:
43Branch(48)
B5:
44MoveLoc[14](loc7: &mut Tick)
45Pop
46LdConst[8](u64: 11)
47Abort
B6:
48CopyLoc[11](loc4: u128)
49LdU128(0)
50Eq
51CopyLoc[12](loc5: u128)
52LdU128(0)
53Eq
54Neq
55StLoc[10](loc3: bool)
56MoveLoc[12](loc5: u128)
57LdU128(0)
58Eq
59BrFalse(80)
B7:
60MoveLoc[1](Arg1: I32)
61MoveLoc[2](Arg2: I32)
62Call i32::lte(I32, I32): bool
63BrFalse(76)
B8:
64MoveLoc[8](loc1: u128)
65CopyLoc[14](loc7: &mut Tick)
66MutBorrowField[41](Tick.fee_growth_outside_a: u128)
67WriteRef
68MoveLoc[9](loc2: u128)
69CopyLoc[14](loc7: &mut Tick)
70MutBorrowField[42](Tick.fee_growth_outside_b: u128)
71WriteRef
72MoveLoc[5](Arg5: vector<u128>)
73CopyLoc[14](loc7: &mut Tick)
74MutBorrowField[43](Tick.reward_growths_outside: vector<u128>)
75WriteRef
B9:
76LdTrue
77CopyLoc[14](loc7: &mut Tick)
78MutBorrowField[44](Tick.initialized: bool)
79WriteRef
B10:
80MoveLoc[11](loc4: u128)
81CopyLoc[14](loc7: &mut Tick)
82MutBorrowField[40](Tick.liquidity_gross: u128)
83WriteRef
84MoveLoc[4](Arg4: bool)
85BrFalse(93)
B11:
86CopyLoc[14](loc7: &mut Tick)
87ImmBorrowField[45](Tick.liquidity_net: I128)
88ReadRef
89MoveLoc[3](Arg3: I128)
90Call i128::sub(I128, I128): I128
91StLoc[7](loc0: I128)
92Branch(99)
B12:
93CopyLoc[14](loc7: &mut Tick)
94ImmBorrowField[45](Tick.liquidity_net: I128)
95ReadRef
96MoveLoc[3](Arg3: I128)
97Call i128::add(I128, I128): I128
98StLoc[7](loc0: I128)
B13:
99MoveLoc[7](loc0: I128)
100MoveLoc[14](loc7: &mut Tick)
101MutBorrowField[45](Tick.liquidity_net: I128)
102WriteRef
103MoveLoc[10](loc3: bool)
104Ret
}
public get_tick<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: I32): &Tick {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[18](Pool.id: UID)
2CopyLoc[1](Arg1: I32)
3Call dynamic_field::exists_<I32>(&UID, I32): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
7Pop
8LdConst[1](u64: 0)
9Abort
B3:
10MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
11ImmBorrowFieldGeneric[18](Pool.id: UID)
12MoveLoc[1](Arg1: I32)
13Call dynamic_field::borrow<I32, Tick>(&UID, I32): &Tick
14Ret
}
init_tick<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: &mut TxContext): &mut Tick {
L3: loc0: u64
L4: loc1: vector<u128>
B0:
0VecPack(72, 0)
1StLoc[4](loc1: vector<u128>)
2LdU64(0)
3StLoc[3](loc0: u64)
B1:
4CopyLoc[3](loc0: u64)
5LdConst[3](u64: 3)
6Lt
7BrFalse(17)
B2:
8Branch(9)
B3:
9MutBorrowLoc[4](loc1: vector<u128>)
10LdU128(0)
11VecPushBack(72)
12MoveLoc[3](loc0: u64)
13LdU64(1)
14Add
15StLoc[3](loc0: u64)
16Branch(4)
B4:
17CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
18MutBorrowFieldGeneric[18](Pool.id: UID)
19CopyLoc[1](Arg1: I32)
20MoveLoc[2](Arg2: &mut TxContext)
21Call object::new(&mut TxContext): UID
22LdU128(0)
23Call i128::zero(): I128
24LdU128(0)
25LdU128(0)
26MoveLoc[4](loc1: vector<u128>)
27LdFalse
28Pack[1](Tick)
29Call dynamic_field::add<I32, Tick>(&mut UID, I32, Tick)
30MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
31MutBorrowFieldGeneric[18](Pool.id: UID)
32MoveLoc[1](Arg1: I32)
33Call dynamic_field::borrow_mut<I32, Tick>(&mut UID, I32): &mut Tick
34Ret
}
cross_tick<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: u128, Arg3: u128, Arg4: &vector<u128>, Arg5: bool, Arg6: &mut TxContext): I128 {
L7: loc0: u64
L8: loc1: u64
L9: loc2: &mut u128
L10: loc3: &u128
L11: loc4: &mut Tick
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[18](Pool.id: UID)
2CopyLoc[1](Arg1: I32)
3Call dynamic_field::exists_<I32>(&UID, I32): bool
4Not
5BrFalse(12)
B1:
6MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
7MoveLoc[1](Arg1: I32)
8MoveLoc[6](Arg6: &mut TxContext)
9Call init_tick<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, &mut TxContext): &mut Tick
10StLoc[11](loc4: &mut Tick)
11Branch(19)
B2:
12MoveLoc[6](Arg6: &mut TxContext)
13Pop
14MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
15MutBorrowFieldGeneric[18](Pool.id: UID)
16MoveLoc[1](Arg1: I32)
17Call dynamic_field::borrow_mut<I32, Tick>(&mut UID, I32): &mut Tick
18StLoc[11](loc4: &mut Tick)
B3:
19MoveLoc[5](Arg5: bool)
20Not
21BrFalse(72)
B4:
22MoveLoc[2](Arg2: u128)
23CopyLoc[11](loc4: &mut Tick)
24ImmBorrowField[41](Tick.fee_growth_outside_a: u128)
25ReadRef
26Call math_u128::wrapping_sub(u128, u128): u128
27CopyLoc[11](loc4: &mut Tick)
28MutBorrowField[41](Tick.fee_growth_outside_a: u128)
29WriteRef
30MoveLoc[3](Arg3: u128)
31CopyLoc[11](loc4: &mut Tick)
32ImmBorrowField[42](Tick.fee_growth_outside_b: u128)
33ReadRef
34Call math_u128::wrapping_sub(u128, u128): u128
35CopyLoc[11](loc4: &mut Tick)
36MutBorrowField[42](Tick.fee_growth_outside_b: u128)
37WriteRef
38LdU64(0)
39StLoc[7](loc0: u64)
40CopyLoc[4](Arg4: &vector<u128>)
41VecLen(72)
42StLoc[8](loc1: u64)
B5:
43CopyLoc[7](loc0: u64)
44CopyLoc[8](loc1: u64)
45Lt
46BrFalse(69)
B6:
47Branch(48)
B7:
48CopyLoc[4](Arg4: &vector<u128>)
49CopyLoc[7](loc0: u64)
50VecImmBorrow(72)
51StLoc[10](loc3: &u128)
52CopyLoc[11](loc4: &mut Tick)
53MutBorrowField[43](Tick.reward_growths_outside: vector<u128>)
54CopyLoc[7](loc0: u64)
55VecMutBorrow(72)
56StLoc[9](loc2: &mut u128)
57MoveLoc[10](loc3: &u128)
58ReadRef
59CopyLoc[9](loc2: &mut u128)
60ReadRef
61Call math_u128::wrapping_sub(u128, u128): u128
62MoveLoc[9](loc2: &mut u128)
63WriteRef
64MoveLoc[7](loc0: u64)
65LdU64(1)
66Add
67StLoc[7](loc0: u64)
68Branch(43)
B8:
69MoveLoc[4](Arg4: &vector<u128>)
70Pop
71Branch(74)
B9:
72MoveLoc[4](Arg4: &vector<u128>)
73Pop
B10:
74MoveLoc[11](loc4: &mut Tick)
75ImmBorrowField[45](Tick.liquidity_net: I128)
76ReadRef
77Ret
}
clear_tick<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: &mut TxContext) {
L3: loc0: &mut Tick
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MutBorrowFieldGeneric[18](Pool.id: UID)
2MoveLoc[1](Arg1: I32)
3Call dynamic_field::borrow_mut<I32, Tick>(&mut UID, I32): &mut Tick
4StLoc[3](loc0: &mut Tick)
5LdU128(0)
6CopyLoc[3](loc0: &mut Tick)
7MutBorrowField[40](Tick.liquidity_gross: u128)
8WriteRef
9Call i128::zero(): I128
10CopyLoc[3](loc0: &mut Tick)
11MutBorrowField[45](Tick.liquidity_net: I128)
12WriteRef
13LdU128(0)
14CopyLoc[3](loc0: &mut Tick)
15MutBorrowField[41](Tick.fee_growth_outside_a: u128)
16WriteRef
17LdU128(0)
18CopyLoc[3](loc0: &mut Tick)
19MutBorrowField[42](Tick.fee_growth_outside_b: u128)
20WriteRef
21LdFalse
22MoveLoc[3](loc0: &mut Tick)
23MutBorrowField[44](Tick.initialized: bool)
24WriteRef
25Ret
}
flip_tick<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: &mut TxContext) {
L3: loc0: u8
L4: loc1: u256
L5: loc2: &mut u256
L6: loc3: I32
B0:
0CopyLoc[1](Arg1: I32)
1CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
2ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
3ReadRef
4Call i32::mod_euclidean(I32, u32): I32
5Call i32::zero(): I32
6Call i32::eq(I32, I32): bool
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
10Pop
11LdConst[9](u64: 12)
12Abort
B3:
13MoveLoc[1](Arg1: I32)
14CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
15ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
16ReadRef
17Call i32::from(u32): I32
18Call i32::div(I32, I32): I32
19Call position_tick(I32): I32 * u8
20StLoc[3](loc0: u8)
21StLoc[6](loc3: I32)
22LdU256(1)
23MoveLoc[3](loc0: u8)
24Shl
25StLoc[4](loc1: u256)
26CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
27CopyLoc[6](loc3: I32)
28Call try_init_tick_word<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32)
29MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
30MoveLoc[6](loc3: I32)
31Call get_tick_word_mut<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32): &mut u256
32StLoc[5](loc2: &mut u256)
33CopyLoc[5](loc2: &mut u256)
34ReadRef
35MoveLoc[4](loc1: u256)
36Xor
37MoveLoc[5](loc2: &mut u256)
38WriteRef
39Ret
}
next_fee_growth_inside<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: I32, Arg3: I32, Arg4: &mut TxContext): u128 * u128 {
L5: loc0: I32
L6: loc1: I32
L7: loc2: u128
L8: loc3: u128
L9: loc4: u128
L10: loc5: u128
L11: loc6: u128
L12: loc7: u128
L13: loc8: &Tick
L14: loc9: &Tick
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1CopyLoc[1](Arg1: I32)
2StLoc[5](loc0: I32)
3FreezeRef
4MoveLoc[5](loc0: I32)
5Call get_tick<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, I32): &Tick
6StLoc[13](loc8: &Tick)
7CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
8CopyLoc[2](Arg2: I32)
9StLoc[6](loc1: I32)
10FreezeRef
11MoveLoc[6](loc1: I32)
12Call get_tick<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, I32): &Tick
13StLoc[14](loc9: &Tick)
14CopyLoc[13](loc8: &Tick)
15ImmBorrowField[44](Tick.initialized: bool)
16ReadRef
17Not
18BrFalse(30)
B1:
19MoveLoc[13](loc8: &Tick)
20Pop
21CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
22ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
23ReadRef
24StLoc[9](loc4: u128)
25CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
26ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
27ReadRef
28StLoc[10](loc5: u128)
29Branch(59)
B2:
30CopyLoc[3](Arg3: I32)
31MoveLoc[1](Arg1: I32)
32Call i32::gte(I32, I32): bool
33BrFalse(43)
B3:
34CopyLoc[13](loc8: &Tick)
35ImmBorrowField[41](Tick.fee_growth_outside_a: u128)
36ReadRef
37StLoc[9](loc4: u128)
38MoveLoc[13](loc8: &Tick)
39ImmBorrowField[42](Tick.fee_growth_outside_b: u128)
40ReadRef
41StLoc[10](loc5: u128)
42Branch(59)
B4:
43CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
44ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
45ReadRef
46CopyLoc[13](loc8: &Tick)
47ImmBorrowField[41](Tick.fee_growth_outside_a: u128)
48ReadRef
49Call math_u128::wrapping_sub(u128, u128): u128
50StLoc[9](loc4: u128)
51CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
52ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
53ReadRef
54MoveLoc[13](loc8: &Tick)
55ImmBorrowField[42](Tick.fee_growth_outside_b: u128)
56ReadRef
57Call math_u128::wrapping_sub(u128, u128): u128
58StLoc[10](loc5: u128)
B5:
59CopyLoc[14](loc9: &Tick)
60ImmBorrowField[44](Tick.initialized: bool)
61ReadRef
62Not
63BrFalse(71)
B6:
64MoveLoc[14](loc9: &Tick)
65Pop
66LdU128(0)
67StLoc[7](loc2: u128)
68LdU128(0)
69StLoc[8](loc3: u128)
70Branch(100)
B7:
71MoveLoc[3](Arg3: I32)
72MoveLoc[2](Arg2: I32)
73Call i32::lt(I32, I32): bool
74BrFalse(84)
B8:
75CopyLoc[14](loc9: &Tick)
76ImmBorrowField[41](Tick.fee_growth_outside_a: u128)
77ReadRef
78StLoc[7](loc2: u128)
79MoveLoc[14](loc9: &Tick)
80ImmBorrowField[42](Tick.fee_growth_outside_b: u128)
81ReadRef
82StLoc[8](loc3: u128)
83Branch(100)
B9:
84CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
85ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
86ReadRef
87CopyLoc[14](loc9: &Tick)
88ImmBorrowField[41](Tick.fee_growth_outside_a: u128)
89ReadRef
90Call math_u128::wrapping_sub(u128, u128): u128
91StLoc[7](loc2: u128)
92CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
93ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
94ReadRef
95MoveLoc[14](loc9: &Tick)
96ImmBorrowField[42](Tick.fee_growth_outside_b: u128)
97ReadRef
98Call math_u128::wrapping_sub(u128, u128): u128
99StLoc[8](loc3: u128)
B10:
100CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
101ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
102ReadRef
103MoveLoc[9](loc4: u128)
104Call math_u128::wrapping_sub(u128, u128): u128
105MoveLoc[7](loc2: u128)
106Call math_u128::wrapping_sub(u128, u128): u128
107StLoc[11](loc6: u128)
108MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
109ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
110ReadRef
111MoveLoc[10](loc5: u128)
112Call math_u128::wrapping_sub(u128, u128): u128
113MoveLoc[8](loc3: u128)
114Call math_u128::wrapping_sub(u128, u128): u128
115StLoc[12](loc7: u128)
116MoveLoc[11](loc6: u128)
117MoveLoc[12](loc7: u128)
118Ret
}
next_reward_growths_inside<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: I32, Arg3: I32, Arg4: &mut TxContext): vector<u128> {
L5: loc0: I32
L6: loc1: I32
L7: loc2: u64
L8: loc3: u64
L9: loc4: u128
L10: loc5: u128
L11: loc6: vector<u128>
L12: loc7: u128
L13: loc8: u128
L14: loc9: &PoolRewardInfo
L15: loc10: &Tick
L16: loc11: &Tick
B0:
0VecPack(72, 0)
1StLoc[11](loc6: vector<u128>)
2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
3CopyLoc[1](Arg1: I32)
4StLoc[5](loc0: I32)
5FreezeRef
6MoveLoc[5](loc0: I32)
7Call get_tick<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, I32): &Tick
8StLoc[15](loc10: &Tick)
9CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
10CopyLoc[2](Arg2: I32)
11StLoc[6](loc1: I32)
12FreezeRef
13MoveLoc[6](loc1: I32)
14Call get_tick<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, I32): &Tick
15StLoc[16](loc11: &Tick)
16LdU64(0)
17StLoc[7](loc2: u64)
18CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
19ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
20VecLen(112)
21StLoc[8](loc3: u64)
B1:
22CopyLoc[7](loc2: u64)
23CopyLoc[8](loc3: u64)
24Lt
25BrFalse(103)
B2:
26Branch(27)
B3:
27CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
28ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
29CopyLoc[7](loc2: u64)
30VecImmBorrow(112)
31StLoc[14](loc9: &PoolRewardInfo)
32CopyLoc[15](loc10: &Tick)
33ImmBorrowField[43](Tick.reward_growths_outside: vector<u128>)
34CopyLoc[7](loc2: u64)
35VecImmBorrow(72)
36ReadRef
37StLoc[12](loc7: u128)
38CopyLoc[16](loc11: &Tick)
39ImmBorrowField[43](Tick.reward_growths_outside: vector<u128>)
40CopyLoc[7](loc2: u64)
41VecImmBorrow(72)
42ReadRef
43StLoc[13](loc8: u128)
44CopyLoc[15](loc10: &Tick)
45ImmBorrowField[44](Tick.initialized: bool)
46ReadRef
47Not
48BrFalse(54)
B4:
49CopyLoc[14](loc9: &PoolRewardInfo)
50ImmBorrowField[28](PoolRewardInfo.growth_global: u128)
51ReadRef
52StLoc[10](loc5: u128)
53Branch(67)
B5:
54CopyLoc[3](Arg3: I32)
55CopyLoc[1](Arg1: I32)
56Call i32::gte(I32, I32): bool
57BrFalse(61)
B6:
58MoveLoc[12](loc7: u128)
59StLoc[10](loc5: u128)
60Branch(67)
B7:
61CopyLoc[14](loc9: &PoolRewardInfo)
62ImmBorrowField[28](PoolRewardInfo.growth_global: u128)
63ReadRef
64MoveLoc[12](loc7: u128)
65Call math_u128::wrapping_sub(u128, u128): u128
66StLoc[10](loc5: u128)
B8:
67CopyLoc[16](loc11: &Tick)
68ImmBorrowField[44](Tick.initialized: bool)
69ReadRef
70Not
71BrFalse(75)
B9:
72LdU128(0)
73StLoc[9](loc4: u128)
74Branch(88)
B10:
75CopyLoc[3](Arg3: I32)
76CopyLoc[2](Arg2: I32)
77Call i32::lt(I32, I32): bool
78BrFalse(82)
B11:
79MoveLoc[13](loc8: u128)
80StLoc[9](loc4: u128)
81Branch(88)
B12:
82CopyLoc[14](loc9: &PoolRewardInfo)
83ImmBorrowField[28](PoolRewardInfo.growth_global: u128)
84ReadRef
85MoveLoc[13](loc8: u128)
86Call math_u128::wrapping_sub(u128, u128): u128
87StLoc[9](loc4: u128)
B13:
88MutBorrowLoc[11](loc6: vector<u128>)
89MoveLoc[14](loc9: &PoolRewardInfo)
90ImmBorrowField[28](PoolRewardInfo.growth_global: u128)
91ReadRef
92MoveLoc[10](loc5: u128)
93Call math_u128::wrapping_sub(u128, u128): u128
94MoveLoc[9](loc4: u128)
95Call math_u128::wrapping_sub(u128, u128): u128
96CopyLoc[7](loc2: u64)
97Call vector::insert<u128>(&mut vector<u128>, u128, u64)
98MoveLoc[7](loc2: u64)
99LdU64(1)
100Add
101StLoc[7](loc2: u64)
102Branch(22)
B14:
103MoveLoc[16](loc11: &Tick)
104Pop
105MoveLoc[15](loc10: &Tick)
106Pop
107MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
108Pop
109MoveLoc[11](loc6: vector<u128>)
110Ret
}
update_position_metadata<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: String, Arg2: I128, Arg3: u128, Arg4: u128, Arg5: vector<u128>, Arg6: &mut TxContext) {
L7: loc0: bool
L8: loc1: u64
L9: loc2: &mut PositionRewardInfo
L10: loc3: u64
L11: loc4: u128
L12: loc5: &mut Position
L13: loc6: u128
L14: loc7: u64
L15: loc8: u64
L16: loc9: u64
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[13](Pool.reward_infos: vector<PoolRewardInfo>)
2VecLen(112)
3StLoc[14](loc7: u64)
4MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
5MoveLoc[1](Arg1: String)
6Call get_position_mut_by_key<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, String): &mut Position
7StLoc[12](loc5: &mut Position)
8CopyLoc[2](Arg2: I128)
9Call i128::zero(): I128
10Call i128::eq(I128, I128): bool
11BrFalse(28)
B1:
12CopyLoc[12](loc5: &mut Position)
13ImmBorrowField[46](Position.liquidity: u128)
14ReadRef
15LdU128(0)
16Gt
17BrFalse(19)
B2:
18Branch(23)
B3:
19MoveLoc[12](loc5: &mut Position)
20Pop
21LdConst[5](u64: 6)
22Abort
B4:
23CopyLoc[12](loc5: &mut Position)
24ImmBorrowField[46](Position.liquidity: u128)
25ReadRef
26StLoc[11](loc4: u128)
27Branch(34)
B5:
28CopyLoc[12](loc5: &mut Position)
29ImmBorrowField[46](Position.liquidity: u128)
30ReadRef
31CopyLoc[2](Arg2: I128)
32Call math_liquidity::add_delta(u128, I128): u128
33StLoc[11](loc4: u128)
B6:
34CopyLoc[3](Arg3: u128)
35CopyLoc[12](loc5: &mut Position)
36ImmBorrowField[47](Position.fee_growth_inside_a: u128)
37ReadRef
38Call math_u128::wrapping_sub(u128, u128): u128
39CopyLoc[12](loc5: &mut Position)
40ImmBorrowField[46](Position.liquidity: u128)
41ReadRef
42LdConst[25](u128: 1844..)
43Call full_math_u128::mul_div_floor(u128, u128, u128): u128
44CastU64
45StLoc[15](loc8: u64)
46CopyLoc[4](Arg4: u128)
47CopyLoc[12](loc5: &mut Position)
48ImmBorrowField[48](Position.fee_growth_inside_b: u128)
49ReadRef
50Call math_u128::wrapping_sub(u128, u128): u128
51CopyLoc[12](loc5: &mut Position)
52ImmBorrowField[46](Position.liquidity: u128)
53ReadRef
54LdConst[25](u128: 1844..)
55Call full_math_u128::mul_div_floor(u128, u128, u128): u128
56CastU64
57StLoc[16](loc9: u64)
58MoveLoc[3](Arg3: u128)
59CopyLoc[12](loc5: &mut Position)
60MutBorrowField[47](Position.fee_growth_inside_a: u128)
61WriteRef
62MoveLoc[4](Arg4: u128)
63CopyLoc[12](loc5: &mut Position)
64MutBorrowField[48](Position.fee_growth_inside_b: u128)
65WriteRef
66CopyLoc[15](loc8: u64)
67LdU64(0)
68Gt
69BrFalse(73)
B7:
70LdTrue
71StLoc[7](loc0: bool)
72Branch(77)
B8:
73CopyLoc[16](loc9: u64)
74LdU64(0)
75Gt
76StLoc[7](loc0: bool)
B9:
77MoveLoc[7](loc0: bool)
78BrFalse(95)
B10:
79CopyLoc[12](loc5: &mut Position)
80ImmBorrowField[25](Position.tokens_owed_a: u64)
81ReadRef
82MoveLoc[15](loc8: u64)
83Call math_u64::wrapping_add(u64, u64): u64
84CopyLoc[12](loc5: &mut Position)
85MutBorrowField[25](Position.tokens_owed_a: u64)
86WriteRef
87CopyLoc[12](loc5: &mut Position)
88ImmBorrowField[26](Position.tokens_owed_b: u64)
89ReadRef
90MoveLoc[16](loc9: u64)
91Call math_u64::wrapping_add(u64, u64): u64
92CopyLoc[12](loc5: &mut Position)
93MutBorrowField[26](Position.tokens_owed_b: u64)
94WriteRef
B11:
95LdU64(0)
96StLoc[10](loc3: u64)
B12:
97CopyLoc[10](loc3: u64)
98CopyLoc[14](loc7: u64)
99Lt
100BrFalse(141)
B13:
101Branch(102)
B14:
102ImmBorrowLoc[5](Arg5: vector<u128>)
103CopyLoc[10](loc3: u64)
104VecImmBorrow(72)
105ReadRef
106StLoc[13](loc6: u128)
107CopyLoc[12](loc5: &mut Position)
108MutBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
109CopyLoc[10](loc3: u64)
110VecMutBorrow(162)
111StLoc[9](loc2: &mut PositionRewardInfo)
112CopyLoc[13](loc6: u128)
113CopyLoc[9](loc2: &mut PositionRewardInfo)
114ImmBorrowField[49](PositionRewardInfo.reward_growth_inside: u128)
115ReadRef
116Call math_u128::wrapping_sub(u128, u128): u128
117CopyLoc[12](loc5: &mut Position)
118ImmBorrowField[46](Position.liquidity: u128)
119ReadRef
120LdConst[25](u128: 1844..)
121Call full_math_u128::mul_div_floor(u128, u128, u128): u128
122CastU64
123StLoc[8](loc1: u64)
124MoveLoc[13](loc6: u128)
125CopyLoc[9](loc2: &mut PositionRewardInfo)
126MutBorrowField[49](PositionRewardInfo.reward_growth_inside: u128)
127WriteRef
128CopyLoc[9](loc2: &mut PositionRewardInfo)
129ImmBorrowField[34](PositionRewardInfo.amount_owed: u64)
130ReadRef
131MoveLoc[8](loc1: u64)
132Call math_u64::wrapping_add(u64, u64): u64
133MoveLoc[9](loc2: &mut PositionRewardInfo)
134MutBorrowField[34](PositionRewardInfo.amount_owed: u64)
135WriteRef
136MoveLoc[10](loc3: u64)
137LdU64(1)
138Add
139StLoc[10](loc3: u64)
140Branch(97)
B15:
141MoveLoc[2](Arg2: I128)
142Call i128::zero(): I128
143Call i128::eq(I128, I128): bool
144Not
145BrFalse(151)
B16:
146MoveLoc[11](loc4: u128)
147MoveLoc[12](loc5: &mut Position)
148MutBorrowField[46](Position.liquidity: u128)
149WriteRef
150Branch(153)
B17:
151MoveLoc[12](loc5: &mut Position)
152Pop
B18:
153Ret
}
public get_position<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32): &Position {
L4: loc0: String
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: address)
2MoveLoc[2](Arg2: I32)
3MoveLoc[3](Arg3: I32)
4Call get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String
5StLoc[4](loc0: String)
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
7MoveLoc[4](loc0: String)
8Call get_position_by_key<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String): &Position
9Ret
}
public check_position_exists<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32): bool {
L4: loc0: String
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: address)
2MoveLoc[2](Arg2: I32)
3MoveLoc[3](Arg3: I32)
4Call get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String
5StLoc[4](loc0: String)
6MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
7ImmBorrowFieldGeneric[18](Pool.id: UID)
8MoveLoc[4](loc0: String)
9Call dynamic_object_field::exists_<String>(&UID, String): bool
10Ret
}
public check_position_exists_old<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32): bool {
L4: loc0: String
B0:
0MoveLoc[1](Arg1: address)
1MoveLoc[2](Arg2: I32)
2MoveLoc[3](Arg3: I32)
3Call get_position_key_old(address, I32, I32): String
4StLoc[4](loc0: String)
5MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
6ImmBorrowFieldGeneric[18](Pool.id: UID)
7MoveLoc[4](loc0: String)
8Call dynamic_object_field::exists_<String>(&UID, String): bool
9Ret
}
get_position_mut<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32): &mut Position {
L4: loc0: address
L5: loc1: I32
L6: loc2: I32
L7: loc3: String
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: address)
2MoveLoc[2](Arg2: I32)
3MoveLoc[3](Arg3: I32)
4StLoc[6](loc2: I32)
5StLoc[5](loc1: I32)
6StLoc[4](loc0: address)
7FreezeRef
8MoveLoc[4](loc0: address)
9MoveLoc[5](loc1: I32)
10MoveLoc[6](loc2: I32)
11Call get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String
12StLoc[7](loc3: String)
13MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
14MoveLoc[7](loc3: String)
15Call get_position_mut_by_key<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, String): &mut Position
16Ret
}
get_position_by_key<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: String): &Position {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[18](Pool.id: UID)
2MoveLoc[1](Arg1: String)
3Call dynamic_object_field::borrow<String, Position>(&UID, String): &Position
4Ret
}
get_position_mut_by_key<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: String): &mut Position {
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MutBorrowFieldGeneric[18](Pool.id: UID)
2MoveLoc[1](Arg1: String)
3Call dynamic_object_field::borrow_mut<String, Position>(&mut UID, String): &mut Position
4Ret
}
public(friend) fetch_ticks<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: u64): vector<TickInfo> * Option<I32> {
L3: loc0: bool
L4: loc1: bool
L5: loc2: vector<TickInfo>
L6: loc3: Option<I32>
L7: loc4: I32
L8: loc5: u64
L9: loc6: bool
L10: loc7: I32
L11: loc8: I32
L12: loc9: &Tick
L13: loc10: vector<TickInfo>
B0:
0CopyLoc[1](Arg1: I32)
1LdConst[24](u32: 443636)
2Call i32::neg_from(u32): I32
3Call i32::gte(I32, I32): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
7Pop
8LdConst[4](u64: 5)
9Abort
B3:
10CopyLoc[1](Arg1: I32)
11LdConst[24](u32: 443636)
12Call i32::from(u32): I32
13Call i32::lte(I32, I32): bool
14BrFalse(16)
B4:
15Branch(20)
B5:
16MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
17Pop
18LdConst[4](u64: 5)
19Abort
B6:
20LdConst[24](u32: 443636)
21Call i32::from_u32(u32): I32
22StLoc[11](loc8: I32)
23VecPack(191, 0)
24StLoc[13](loc10: vector<TickInfo>)
25MoveLoc[1](Arg1: I32)
26StLoc[7](loc4: I32)
27LdU64(0)
28StLoc[8](loc5: u64)
B7:
29CopyLoc[7](loc4: I32)
30CopyLoc[11](loc8: I32)
31Call i32::lt(I32, I32): bool
32BrFalse(39)
B8:
33Branch(34)
B9:
34CopyLoc[8](loc5: u64)
35CopyLoc[2](Arg2: u64)
36Lt
37StLoc[3](loc0: bool)
38Branch(41)
B10:
39LdFalse
40StLoc[3](loc0: bool)
B11:
41MoveLoc[3](loc0: bool)
42BrFalse(87)
B12:
43CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
44MoveLoc[7](loc4: I32)
45LdFalse
46Call next_initialized_tick_within_one_word<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, I32, bool): I32 * bool
47StLoc[9](loc6: bool)
48StLoc[10](loc7: I32)
49MoveLoc[9](loc6: bool)
50BrFalse(80)
B13:
51CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
52ImmBorrowFieldGeneric[18](Pool.id: UID)
53CopyLoc[10](loc7: I32)
54Call dynamic_field::borrow<I32, Tick>(&UID, I32): &Tick
55StLoc[12](loc9: &Tick)
56MutBorrowLoc[13](loc10: vector<TickInfo>)
57CopyLoc[12](loc9: &Tick)
58Call object::id<Tick>(&Tick): ID
59CopyLoc[10](loc7: I32)
60CopyLoc[12](loc9: &Tick)
61ImmBorrowField[40](Tick.liquidity_gross: u128)
62ReadRef
63CopyLoc[12](loc9: &Tick)
64ImmBorrowField[45](Tick.liquidity_net: I128)
65ReadRef
66CopyLoc[12](loc9: &Tick)
67ImmBorrowField[41](Tick.fee_growth_outside_a: u128)
68ReadRef
69CopyLoc[12](loc9: &Tick)
70ImmBorrowField[42](Tick.fee_growth_outside_b: u128)
71ReadRef
72CopyLoc[12](loc9: &Tick)
73ImmBorrowField[43](Tick.reward_growths_outside: vector<u128>)
74ReadRef
75MoveLoc[12](loc9: &Tick)
76ImmBorrowField[44](Tick.initialized: bool)
77ReadRef
78Pack[2](TickInfo)
79VecPushBack(191)
B14:
80MoveLoc[8](loc5: u64)
81LdU64(1)
82Add
83StLoc[8](loc5: u64)
84MoveLoc[10](loc7: I32)
85StLoc[7](loc4: I32)
86Branch(29)
B15:
87MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
88Pop
89CopyLoc[7](loc4: I32)
90MoveLoc[11](loc8: I32)
91Call i32::lt(I32, I32): bool
92BrFalse(98)
B16:
93MoveLoc[8](loc5: u64)
94MoveLoc[2](Arg2: u64)
95Ge
96StLoc[4](loc1: bool)
97Branch(100)
B17:
98LdFalse
99StLoc[4](loc1: bool)
B18:
100MoveLoc[4](loc1: bool)
101BrFalse(108)
B19:
102MoveLoc[13](loc10: vector<TickInfo>)
103MoveLoc[7](loc4: I32)
104Call option::some<I32>(I32): Option<I32>
105StLoc[6](loc3: Option<I32>)
106StLoc[5](loc2: vector<TickInfo>)
107Branch(112)
B20:
108MoveLoc[13](loc10: vector<TickInfo>)
109Call option::none<I32>(): Option<I32>
110StLoc[6](loc3: Option<I32>)
111StLoc[5](loc2: vector<TickInfo>)
B21:
112MoveLoc[5](loc2: vector<TickInfo>)
113MoveLoc[6](loc3: Option<I32>)
114Ret
}
public get_position_key_fix<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: address, Arg2: I32, Arg3: I32): String {
L4: loc0: String
B0:
0CopyLoc[1](Arg1: address)
1CopyLoc[2](Arg2: I32)
2Call i32::abs_u32(I32): u32
3CopyLoc[2](Arg2: I32)
4Call i32::is_neg(I32): bool
5CopyLoc[3](Arg3: I32)
6Call i32::abs_u32(I32): u32
7CopyLoc[3](Arg3: I32)
8Call i32::is_neg(I32): bool
9Call string_tools::get_position_key_old(address, u32, bool, u32, bool): String
10StLoc[4](loc0: String)
11MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
12ImmBorrowFieldGeneric[18](Pool.id: UID)
13CopyLoc[4](loc0: String)
14Call dynamic_object_field::exists_<String>(&UID, String): bool
15BrFalse(18)
B1:
16MoveLoc[4](loc0: String)
17Ret
B2:
18MoveLoc[1](Arg1: address)
19CopyLoc[2](Arg2: I32)
20Call i32::abs_u32(I32): u32
21MoveLoc[2](Arg2: I32)
22Call i32::is_neg(I32): bool
23CopyLoc[3](Arg3: I32)
24Call i32::abs_u32(I32): u32
25MoveLoc[3](Arg3: I32)
26Call i32::is_neg(I32): bool
27Call string_tools::get_position_key(address, u32, bool, u32, bool): String
28Ret
}
public get_position_key(Arg0: address, Arg1: I32, Arg2: I32): String {
B0:
0MoveLoc[0](Arg0: address)
1CopyLoc[1](Arg1: I32)
2Call i32::abs_u32(I32): u32
3MoveLoc[1](Arg1: I32)
4Call i32::is_neg(I32): bool
5CopyLoc[2](Arg2: I32)
6Call i32::abs_u32(I32): u32
7MoveLoc[2](Arg2: I32)
8Call i32::is_neg(I32): bool
9Call string_tools::get_position_key(address, u32, bool, u32, bool): String
10Ret
}
public get_position_key_old(Arg0: address, Arg1: I32, Arg2: I32): String {
B0:
0MoveLoc[0](Arg0: address)
1CopyLoc[1](Arg1: I32)
2Call i32::abs_u32(I32): u32
3MoveLoc[1](Arg1: I32)
4Call i32::is_neg(I32): bool
5CopyLoc[2](Arg2: I32)
6Call i32::abs_u32(I32): u32
7MoveLoc[2](Arg2: I32)
8Call i32::is_neg(I32): bool
9Call string_tools::get_position_key_old(address, u32, bool, u32, bool): String
10Ret
}
public get_pool_fee<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): u32 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[9](Pool.fee: u32)
2ReadRef
3Ret
}
public get_pool_unlocked<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): bool {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[0](Pool.unlocked: bool)
2ReadRef
3Ret
}
public get_pool_sqrt_price<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[4](Pool.sqrt_price: u128)
2ReadRef
3Ret
}
public get_pool_tick_spacing<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): u32 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[16](Pool.tick_spacing: u32)
2ReadRef
3Ret
}
public get_pool_current_index<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): I32 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[5](Pool.tick_current_index: I32)
2ReadRef
3Ret
}
public get_pool_liquidity<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[8](Pool.liquidity: u128)
2ReadRef
3Ret
}
public get_tick_liquidity_gross(Arg0: &Tick): u128 {
B0:
0MoveLoc[0](Arg0: &Tick)
1ImmBorrowField[40](Tick.liquidity_gross: u128)
2ReadRef
3Ret
}
public get_tick_liquidity_net(Arg0: &Tick): I128 {
B0:
0MoveLoc[0](Arg0: &Tick)
1ImmBorrowField[45](Tick.liquidity_net: I128)
2ReadRef
3Ret
}
public get_tick_initialized(Arg0: &Tick): bool {
B0:
0MoveLoc[0](Arg0: &Tick)
1ImmBorrowField[44](Tick.initialized: bool)
2ReadRef
3Ret
}
public get_tick_fee_growth_outside(Arg0: &Tick): u128 * u128 {
B0:
0CopyLoc[0](Arg0: &Tick)
1ImmBorrowField[41](Tick.fee_growth_outside_a: u128)
2ReadRef
3MoveLoc[0](Arg0: &Tick)
4ImmBorrowField[42](Tick.fee_growth_outside_b: u128)
5ReadRef
6Ret
}
public get_tick_reward_growths_outside(Arg0: &Tick): vector<u128> {
B0:
0MoveLoc[0](Arg0: &Tick)
1ImmBorrowField[43](Tick.reward_growths_outside: vector<u128>)
2ReadRef
3Ret
}
public get_pool_fee_growth_global<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): u128 * u128 {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[6](Pool.fee_growth_global_a: u128)
2ReadRef
3MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
4ImmBorrowFieldGeneric[7](Pool.fee_growth_global_b: u128)
5ReadRef
6Ret
}
public get_pool_reward_last_updated_time_ms<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[15](Pool.reward_last_updated_time_ms: u64)
2ReadRef
3Ret
}
public get_position_fee_growth_inside_a<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: String): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: String)
2Call get_position_by_key<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String): &Position
3ImmBorrowField[47](Position.fee_growth_inside_a: u128)
4ReadRef
5Ret
}
public get_position_base_info<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: String): u128 * u128 * u128 * u64 * u64 * &vector<PositionRewardInfo> {
L2: loc0: &Position
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: String)
2Call get_position_by_key<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String): &Position
3StLoc[2](loc0: &Position)
4CopyLoc[2](loc0: &Position)
5ImmBorrowField[46](Position.liquidity: u128)
6ReadRef
7CopyLoc[2](loc0: &Position)
8ImmBorrowField[47](Position.fee_growth_inside_a: u128)
9ReadRef
10CopyLoc[2](loc0: &Position)
11ImmBorrowField[48](Position.fee_growth_inside_b: u128)
12ReadRef
13CopyLoc[2](loc0: &Position)
14ImmBorrowField[25](Position.tokens_owed_a: u64)
15ReadRef
16CopyLoc[2](loc0: &Position)
17ImmBorrowField[26](Position.tokens_owed_b: u64)
18ReadRef
19MoveLoc[2](loc0: &Position)
20ImmBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
21Ret
}
public get_position_reward_infos<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: String): &vector<PositionRewardInfo> {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: String)
2Call get_position_by_key<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String): &Position
3ImmBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
4Ret
}
public get_position_reward_info(Arg0: &PositionRewardInfo): u128 * u64 {
B0:
0CopyLoc[0](Arg0: &PositionRewardInfo)
1ImmBorrowField[49](PositionRewardInfo.reward_growth_inside: u128)
2ReadRef
3MoveLoc[0](Arg0: &PositionRewardInfo)
4ImmBorrowField[34](PositionRewardInfo.amount_owed: u64)
5ReadRef
6Ret
}
public get_position_fee_growth_inside_b<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: String): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: String)
2Call get_position_by_key<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String): &Position
3ImmBorrowField[48](Position.fee_growth_inside_b: u128)
4ReadRef
5Ret
}
public get_flash_swap_receipt_info<Ty0, Ty1>(Arg0: &FlashSwapReceipt<Ty0, Ty1>): ID * bool * u64 {
B0:
0CopyLoc[0](Arg0: &FlashSwapReceipt<Ty0, Ty1>)
1ImmBorrowFieldGeneric[20](FlashSwapReceipt.pool_id: ID)
2ReadRef
3CopyLoc[0](Arg0: &FlashSwapReceipt<Ty0, Ty1>)
4ImmBorrowFieldGeneric[21](FlashSwapReceipt.a_to_b: bool)
5ReadRef
6MoveLoc[0](Arg0: &FlashSwapReceipt<Ty0, Ty1>)
7ImmBorrowFieldGeneric[22](FlashSwapReceipt.pay_amount: u64)
8ReadRef
9Ret
}
public(friend) merge_coin<Ty0>(Arg0: vector<Coin<Ty0>>): Coin<Ty0> {
L1: loc0: Coin<Ty0>
B0:
0ImmBorrowLoc[0](Arg0: vector<Coin<Ty0>>)
1VecLen(80)
2LdU64(0)
3Gt
4BrFalse(6)
B1:
5Branch(8)
B2:
6LdConst[17](u64: 21)
7Abort
B3:
8MutBorrowLoc[0](Arg0: vector<Coin<Ty0>>)
9VecPopBack(80)
10StLoc[1](loc0: Coin<Ty0>)
11MutBorrowLoc[1](loc0: Coin<Ty0>)
12MoveLoc[0](Arg0: vector<Coin<Ty0>>)
13Call pay::join_vec<Ty0>(&mut Coin<Ty0>, vector<Coin<Ty0>>)
14MoveLoc[1](loc0: Coin<Ty0>)
15Ret
}
public(friend) transfer_in<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: Coin<Ty1>) {
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
2MoveLoc[1](Arg1: Coin<Ty0>)
3Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
4Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
5Pop
6MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
7MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
8MoveLoc[2](Arg2: Coin<Ty1>)
9Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
10Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
11Pop
12Ret
}
public(friend) transfer_out<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) split_out_and_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: u64, Arg2: u64, Arg3: &mut TxContext): Coin<Ty0> * Coin<Ty1> {
L4: loc0: Coin<Ty0>
L5: loc1: Coin<Ty1>
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
2MoveLoc[1](Arg1: u64)
3Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
4CopyLoc[3](Arg3: &mut TxContext)
5Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
6StLoc[4](loc0: Coin<Ty0>)
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
8MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
9MoveLoc[2](Arg2: u64)
10Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
11MoveLoc[3](Arg3: &mut TxContext)
12Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
13StLoc[5](loc1: Coin<Ty1>)
14MoveLoc[4](loc0: Coin<Ty0>)
15MoveLoc[5](loc1: Coin<Ty1>)
16Ret
}
public(friend) split_and_transfer<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: u64, Arg3: Coin<Ty1>, Arg4: u64, Arg5: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) split_and_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: u64, Arg3: Coin<Ty1>, Arg4: u64, Arg5: &mut TxContext): Coin<Ty0> * Coin<Ty1> {
L6: loc0: Coin<Ty0>
L7: loc1: Coin<Ty1>
B0:
0MutBorrowLoc[1](Arg1: Coin<Ty0>)
1MoveLoc[2](Arg2: u64)
2CopyLoc[5](Arg5: &mut TxContext)
3Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
4StLoc[6](loc0: Coin<Ty0>)
5MutBorrowLoc[3](Arg3: Coin<Ty1>)
6MoveLoc[4](Arg4: u64)
7MoveLoc[5](Arg5: &mut TxContext)
8Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
9StLoc[7](loc1: Coin<Ty1>)
10MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
11MoveLoc[6](loc0: Coin<Ty0>)
12MoveLoc[7](loc1: Coin<Ty1>)
13Call transfer_in<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, Coin<Ty0>, Coin<Ty1>)
14MoveLoc[1](Arg1: Coin<Ty0>)
15MoveLoc[3](Arg3: Coin<Ty1>)
16Ret
}
public(friend) swap_coin_a_b<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: u64, Arg3: u64, Arg4: address, Arg5: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) swap_coin_a_b_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: u64, Arg3: u64, Arg4: &mut TxContext): Coin<Ty1> * Coin<Ty0> {
L5: loc0: Coin<Ty0>
B0:
0MutBorrowLoc[1](Arg1: Coin<Ty0>)
1MoveLoc[2](Arg2: u64)
2CopyLoc[4](Arg4: &mut TxContext)
3Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
4StLoc[5](loc0: Coin<Ty0>)
5CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
7MoveLoc[5](loc0: Coin<Ty0>)
8Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
9Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
10Pop
11MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
12MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
13MoveLoc[3](Arg3: u64)
14Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
15MoveLoc[4](Arg4: &mut TxContext)
16Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
17MoveLoc[1](Arg1: Coin<Ty0>)
18Ret
}
public(friend) swap_coin_b_a<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty1>, Arg2: u64, Arg3: u64, Arg4: address, Arg5: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) swap_coin_b_a_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty1>, Arg2: u64, Arg3: u64, Arg4: &mut TxContext): Coin<Ty0> * Coin<Ty1> {
L5: loc0: Coin<Ty1>
B0:
0MutBorrowLoc[1](Arg1: Coin<Ty1>)
1MoveLoc[2](Arg2: u64)
2CopyLoc[4](Arg4: &mut TxContext)
3Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
4StLoc[5](loc0: Coin<Ty1>)
5CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
6MutBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
7MoveLoc[5](loc0: Coin<Ty1>)
8Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
9Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
10Pop
11MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
12MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
13MoveLoc[3](Arg3: u64)
14Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
15MoveLoc[4](Arg4: &mut TxContext)
16Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
17MoveLoc[1](Arg1: Coin<Ty1>)
18Ret
}
public(friend) swap_coin_a_b_b_c<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty0, Ty2, Ty1>, Arg1: &mut Pool<Ty2, Ty4, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: address, Arg7: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) swap_coin_a_b_b_c_with_return_<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty0, Ty2, Ty1>, Arg1: &mut Pool<Ty2, Ty4, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &mut TxContext): Coin<Ty4> * Coin<Ty0> {
L7: loc0: Coin<Ty0>
L8: loc1: Coin<Ty2>
B0:
0MutBorrowLoc[2](Arg2: Coin<Ty0>)
1MoveLoc[3](Arg3: u64)
2CopyLoc[6](Arg6: &mut TxContext)
3Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
4StLoc[7](loc0: Coin<Ty0>)
5CopyLoc[0](Arg0: &mut Pool<Ty0, Ty2, Ty1>)
6MutBorrowFieldGeneric[23](Pool.coin_a: Balance<Ty0>)
7MoveLoc[7](loc0: Coin<Ty0>)
8Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
9Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
10Pop
11MoveLoc[0](Arg0: &mut Pool<Ty0, Ty2, Ty1>)
12MutBorrowFieldGeneric[24](Pool.coin_b: Balance<Ty2>)
13MoveLoc[4](Arg4: u64)
14Call balance::split<Ty2>(&mut Balance<Ty2>, u64): Balance<Ty2>
15CopyLoc[6](Arg6: &mut TxContext)
16Call coin::from_balance<Ty2>(Balance<Ty2>, &mut TxContext): Coin<Ty2>
17StLoc[8](loc1: Coin<Ty2>)
18CopyLoc[1](Arg1: &mut Pool<Ty2, Ty4, Ty3>)
19MutBorrowFieldGeneric[25](Pool.coin_a: Balance<Ty2>)
20MoveLoc[8](loc1: Coin<Ty2>)
21Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
22Call balance::join<Ty2>(&mut Balance<Ty2>, Balance<Ty2>): u64
23Pop
24MoveLoc[1](Arg1: &mut Pool<Ty2, Ty4, Ty3>)
25MutBorrowFieldGeneric[26](Pool.coin_b: Balance<Ty4>)
26MoveLoc[5](Arg5: u64)
27Call balance::split<Ty4>(&mut Balance<Ty4>, u64): Balance<Ty4>
28MoveLoc[6](Arg6: &mut TxContext)
29Call coin::from_balance<Ty4>(Balance<Ty4>, &mut TxContext): Coin<Ty4>
30MoveLoc[2](Arg2: Coin<Ty0>)
31Ret
}
public(friend) swap_coin_a_b_c_b<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty0, Ty2, Ty1>, Arg1: &mut Pool<Ty4, Ty2, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: address, Arg7: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) swap_coin_a_b_c_b_with_return_<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty0, Ty2, Ty1>, Arg1: &mut Pool<Ty4, Ty2, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &mut TxContext): Coin<Ty4> * Coin<Ty0> {
L7: loc0: Coin<Ty0>
L8: loc1: Coin<Ty2>
B0:
0MutBorrowLoc[2](Arg2: Coin<Ty0>)
1MoveLoc[3](Arg3: u64)
2CopyLoc[6](Arg6: &mut TxContext)
3Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
4StLoc[7](loc0: Coin<Ty0>)
5CopyLoc[0](Arg0: &mut Pool<Ty0, Ty2, Ty1>)
6MutBorrowFieldGeneric[23](Pool.coin_a: Balance<Ty0>)
7MoveLoc[7](loc0: Coin<Ty0>)
8Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
9Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
10Pop
11MoveLoc[0](Arg0: &mut Pool<Ty0, Ty2, Ty1>)
12MutBorrowFieldGeneric[24](Pool.coin_b: Balance<Ty2>)
13MoveLoc[4](Arg4: u64)
14Call balance::split<Ty2>(&mut Balance<Ty2>, u64): Balance<Ty2>
15CopyLoc[6](Arg6: &mut TxContext)
16Call coin::from_balance<Ty2>(Balance<Ty2>, &mut TxContext): Coin<Ty2>
17StLoc[8](loc1: Coin<Ty2>)
18CopyLoc[1](Arg1: &mut Pool<Ty4, Ty2, Ty3>)
19MutBorrowFieldGeneric[27](Pool.coin_b: Balance<Ty2>)
20MoveLoc[8](loc1: Coin<Ty2>)
21Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
22Call balance::join<Ty2>(&mut Balance<Ty2>, Balance<Ty2>): u64
23Pop
24MoveLoc[1](Arg1: &mut Pool<Ty4, Ty2, Ty3>)
25MutBorrowFieldGeneric[28](Pool.coin_a: Balance<Ty4>)
26MoveLoc[5](Arg5: u64)
27Call balance::split<Ty4>(&mut Balance<Ty4>, u64): Balance<Ty4>
28MoveLoc[6](Arg6: &mut TxContext)
29Call coin::from_balance<Ty4>(Balance<Ty4>, &mut TxContext): Coin<Ty4>
30MoveLoc[2](Arg2: Coin<Ty0>)
31Ret
}
public(friend) swap_coin_b_a_b_c<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty2, Ty0, Ty1>, Arg1: &mut Pool<Ty2, Ty4, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: address, Arg7: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) swap_coin_b_a_b_c_with_return_<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty2, Ty0, Ty1>, Arg1: &mut Pool<Ty2, Ty4, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &mut TxContext): Coin<Ty4> * Coin<Ty0> {
L7: loc0: Coin<Ty0>
L8: loc1: Coin<Ty2>
B0:
0MutBorrowLoc[2](Arg2: Coin<Ty0>)
1MoveLoc[3](Arg3: u64)
2CopyLoc[6](Arg6: &mut TxContext)
3Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
4StLoc[7](loc0: Coin<Ty0>)
5CopyLoc[0](Arg0: &mut Pool<Ty2, Ty0, Ty1>)
6MutBorrowFieldGeneric[29](Pool.coin_b: Balance<Ty0>)
7MoveLoc[7](loc0: Coin<Ty0>)
8Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
9Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
10Pop
11MoveLoc[0](Arg0: &mut Pool<Ty2, Ty0, Ty1>)
12MutBorrowFieldGeneric[30](Pool.coin_a: Balance<Ty2>)
13MoveLoc[4](Arg4: u64)
14Call balance::split<Ty2>(&mut Balance<Ty2>, u64): Balance<Ty2>
15CopyLoc[6](Arg6: &mut TxContext)
16Call coin::from_balance<Ty2>(Balance<Ty2>, &mut TxContext): Coin<Ty2>
17StLoc[8](loc1: Coin<Ty2>)
18CopyLoc[1](Arg1: &mut Pool<Ty2, Ty4, Ty3>)
19MutBorrowFieldGeneric[25](Pool.coin_a: Balance<Ty2>)
20MoveLoc[8](loc1: Coin<Ty2>)
21Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
22Call balance::join<Ty2>(&mut Balance<Ty2>, Balance<Ty2>): u64
23Pop
24MoveLoc[1](Arg1: &mut Pool<Ty2, Ty4, Ty3>)
25MutBorrowFieldGeneric[26](Pool.coin_b: Balance<Ty4>)
26MoveLoc[5](Arg5: u64)
27Call balance::split<Ty4>(&mut Balance<Ty4>, u64): Balance<Ty4>
28MoveLoc[6](Arg6: &mut TxContext)
29Call coin::from_balance<Ty4>(Balance<Ty4>, &mut TxContext): Coin<Ty4>
30MoveLoc[2](Arg2: Coin<Ty0>)
31Ret
}
public(friend) swap_coin_b_a_c_b<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty2, Ty0, Ty1>, Arg1: &mut Pool<Ty4, Ty2, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: address, Arg7: &mut TxContext) {
B0:
0LdU64(0)
1Abort
}
public(friend) swap_coin_b_a_c_b_with_return_<Ty0, Ty1, Ty2, Ty3, Ty4>(Arg0: &mut Pool<Ty2, Ty0, Ty1>, Arg1: &mut Pool<Ty4, Ty2, Ty3>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &mut TxContext): Coin<Ty4> * Coin<Ty0> {
L7: loc0: Coin<Ty0>
L8: loc1: Coin<Ty2>
B0:
0MutBorrowLoc[2](Arg2: Coin<Ty0>)
1MoveLoc[3](Arg3: u64)
2CopyLoc[6](Arg6: &mut TxContext)
3Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
4StLoc[7](loc0: Coin<Ty0>)
5CopyLoc[0](Arg0: &mut Pool<Ty2, Ty0, Ty1>)
6MutBorrowFieldGeneric[29](Pool.coin_b: Balance<Ty0>)
7MoveLoc[7](loc0: Coin<Ty0>)
8Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
9Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
10Pop
11MoveLoc[0](Arg0: &mut Pool<Ty2, Ty0, Ty1>)
12MutBorrowFieldGeneric[30](Pool.coin_a: Balance<Ty2>)
13MoveLoc[4](Arg4: u64)
14Call balance::split<Ty2>(&mut Balance<Ty2>, u64): Balance<Ty2>
15CopyLoc[6](Arg6: &mut TxContext)
16Call coin::from_balance<Ty2>(Balance<Ty2>, &mut TxContext): Coin<Ty2>
17StLoc[8](loc1: Coin<Ty2>)
18CopyLoc[1](Arg1: &mut Pool<Ty4, Ty2, Ty3>)
19MutBorrowFieldGeneric[27](Pool.coin_b: Balance<Ty2>)
20MoveLoc[8](loc1: Coin<Ty2>)
21Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
22Call balance::join<Ty2>(&mut Balance<Ty2>, Balance<Ty2>): u64
23Pop
24MoveLoc[1](Arg1: &mut Pool<Ty4, Ty2, Ty3>)
25MutBorrowFieldGeneric[28](Pool.coin_a: Balance<Ty4>)
26MoveLoc[5](Arg5: u64)
27Call balance::split<Ty4>(&mut Balance<Ty4>, u64): Balance<Ty4>
28MoveLoc[6](Arg6: &mut TxContext)
29Call coin::from_balance<Ty4>(Balance<Ty4>, &mut TxContext): Coin<Ty4>
30MoveLoc[2](Arg2: Coin<Ty0>)
31Ret
}
public get_pool_balance<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
1ImmBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)
2Call balance::value<Ty0>(&Balance<Ty0>): u64
3MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)
4ImmBorrowFieldGeneric[1](Pool.coin_b: Balance<Ty1>)
5Call balance::value<Ty1>(&Balance<Ty1>): u64
6Ret
}
public(friend) migrate_position<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: String, Arg2: String, Arg3: &mut TxContext) {
L4: loc0: String
L5: loc1: u64
L6: loc2: &Position
L7: loc3: &PositionRewardInfo
L8: loc4: vector<PositionRewardInfo>
L9: loc5: &vector<PositionRewardInfo>
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1CopyLoc[1](Arg1: String)
2StLoc[4](loc0: String)
3FreezeRef
4MoveLoc[4](loc0: String)
5Call get_position_by_key<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String): &Position
6StLoc[6](loc2: &Position)
7VecPack(162, 0)
8StLoc[8](loc4: vector<PositionRewardInfo>)
9CopyLoc[6](loc2: &Position)
10ImmBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
11StLoc[9](loc5: &vector<PositionRewardInfo>)
12LdU64(0)
13StLoc[5](loc1: u64)
B1:
14CopyLoc[5](loc1: u64)
15LdConst[3](u64: 3)
16Lt
17BrFalse(37)
B2:
18Branch(19)
B3:
19CopyLoc[9](loc5: &vector<PositionRewardInfo>)
20CopyLoc[5](loc1: u64)
21VecImmBorrow(162)
22StLoc[7](loc3: &PositionRewardInfo)
23MutBorrowLoc[8](loc4: vector<PositionRewardInfo>)
24CopyLoc[7](loc3: &PositionRewardInfo)
25ImmBorrowField[49](PositionRewardInfo.reward_growth_inside: u128)
26ReadRef
27MoveLoc[7](loc3: &PositionRewardInfo)
28ImmBorrowField[34](PositionRewardInfo.amount_owed: u64)
29ReadRef
30Pack[3](PositionRewardInfo)
31VecPushBack(162)
32MoveLoc[5](loc1: u64)
33LdU64(1)
34Add
35StLoc[5](loc1: u64)
36Branch(14)
B4:
37MoveLoc[9](loc5: &vector<PositionRewardInfo>)
38Pop
39CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
40CopyLoc[2](Arg2: String)
41MoveLoc[3](Arg3: &mut TxContext)
42Call object::new(&mut TxContext): UID
43CopyLoc[6](loc2: &Position)
44ImmBorrowField[46](Position.liquidity: u128)
45ReadRef
46CopyLoc[6](loc2: &Position)
47ImmBorrowField[47](Position.fee_growth_inside_a: u128)
48ReadRef
49CopyLoc[6](loc2: &Position)
50ImmBorrowField[48](Position.fee_growth_inside_b: u128)
51ReadRef
52CopyLoc[6](loc2: &Position)
53ImmBorrowField[25](Position.tokens_owed_a: u64)
54ReadRef
55MoveLoc[6](loc2: &Position)
56ImmBorrowField[26](Position.tokens_owed_b: u64)
57ReadRef
58MoveLoc[8](loc4: vector<PositionRewardInfo>)
59Pack[4](Position)
60Call save_position<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, String, Position)
61CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
62CopyLoc[1](Arg1: String)
63Call clean_position<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, String)
64MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
65FreezeRef
66Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID
67MoveLoc[1](Arg1: String)
68MoveLoc[2](Arg2: String)
69Pack[28](MigratePositionEvent)
70Call event::emit<MigratePositionEvent>(MigratePositionEvent)
71Ret
}
public(friend) modify_tick_reward<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: I32) {
B0:
0LdU64(0)
1Abort
}
public(friend) modify_tick<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32) {
B0:
0LdU64(0)
1Abort
}
public(friend) modify_position_reward_inside<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: I32, Arg2: I32, Arg3: address, Arg4: u64, Arg5: u128) {
L6: loc0: &mut PositionRewardInfo
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MoveLoc[3](Arg3: address)
2MoveLoc[1](Arg1: I32)
3MoveLoc[2](Arg2: I32)
4Call get_position_mut<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32): &mut Position
5MutBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
6MoveLoc[4](Arg4: u64)
7VecMutBorrow(162)
8StLoc[6](loc0: &mut PositionRewardInfo)
9MoveLoc[5](Arg5: u128)
10MoveLoc[6](loc0: &mut PositionRewardInfo)
11MutBorrowField[49](PositionRewardInfo.reward_growth_inside: u128)
12WriteRef
13Ret
}
save_position<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: String, Arg2: Position) {
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MutBorrowFieldGeneric[18](Pool.id: UID)
2MoveLoc[1](Arg1: String)
3MoveLoc[2](Arg2: Position)
4Call dynamic_object_field::add<String, Position>(&mut UID, String, Position)
5Ret
}
clean_position<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: String) {
L2: loc0: u64
L3: loc1: &mut Position
L4: loc2: &mut PositionRewardInfo
L5: loc3: &mut vector<PositionRewardInfo>
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
1MoveLoc[1](Arg1: String)
2Call get_position_mut_by_key<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, String): &mut Position
3StLoc[3](loc1: &mut Position)
4CopyLoc[3](loc1: &mut Position)
5MutBorrowField[33](Position.reward_infos: vector<PositionRewardInfo>)
6StLoc[5](loc3: &mut vector<PositionRewardInfo>)
7LdU64(0)
8StLoc[2](loc0: u64)
B1:
9CopyLoc[2](loc0: u64)
10LdConst[3](u64: 3)
11Lt
12BrFalse(31)
B2:
13Branch(14)
B3:
14CopyLoc[5](loc3: &mut vector<PositionRewardInfo>)
15CopyLoc[2](loc0: u64)
16VecMutBorrow(162)
17StLoc[4](loc2: &mut PositionRewardInfo)
18LdU128(0)
19CopyLoc[4](loc2: &mut PositionRewardInfo)
20MutBorrowField[49](PositionRewardInfo.reward_growth_inside: u128)
21WriteRef
22LdU64(0)
23MoveLoc[4](loc2: &mut PositionRewardInfo)
24MutBorrowField[34](PositionRewardInfo.amount_owed: u64)
25WriteRef
26MoveLoc[2](loc0: u64)
27LdU64(1)
28Add
29StLoc[2](loc0: u64)
30Branch(9)
B4:
31MoveLoc[5](loc3: &mut vector<PositionRewardInfo>)
32Pop
33LdU128(0)
34CopyLoc[3](loc1: &mut Position)
35MutBorrowField[46](Position.liquidity: u128)
36WriteRef
37LdU128(0)
38CopyLoc[3](loc1: &mut Position)
39MutBorrowField[47](Position.fee_growth_inside_a: u128)
40WriteRef
41LdU128(0)
42CopyLoc[3](loc1: &mut Position)
43MutBorrowField[48](Position.fee_growth_inside_b: u128)
44WriteRef
45LdU64(0)
46CopyLoc[3](loc1: &mut Position)
47MutBorrowField[25](Position.tokens_owed_a: u64)
48WriteRef
49LdU64(0)
50MoveLoc[3](loc1: &mut Position)
51MutBorrowField[26](Position.tokens_owed_b: u64)
52WriteRef
53Ret
}
Constants [
0 => u64: 18
1 => u64: 0
2 => u64: 1
3 => u64: 3
4 => u64: 5
5 => u64: 6
6 => u64: 7
7 => u64: 8
8 => u64: 11
9 => u64: 12
10 => u64: 13
11 => u64: 14
12 => u64: 15
13 => u64: 16
14 => u64: 17
15 => u64: 19
16 => u64: 20
17 => u64: 21
18 => u64: 22
19 => u64: 23
20 => u64: 24
21 => u64: 25
22 => u64: 26
23 => u64: 27
24 => u32: 443636
25 => u128: 18446744073709551616
26 => u8: 64
27 => u128: 4295048016
28 => u128: 79226673515401279992447579055
29 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}