pool
Module0xde2c…c772
- Move path
- 0x2592…f26d::pool
- Functions
- 6049 public, 0 entry
- Structs
- 19
- Friend modules
- pool_manager
pool
Bytecode3399 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d.pool {
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::admin_cap;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::constants;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::full_math_u128;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::full_math_u64;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::i128;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::i32;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::i64;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::liquidity_math;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::oracle;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::position;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::sqrt_price_math;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::swap_math;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::tick;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::tick_bitmap;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::tick_math;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::utils;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::versioned;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::math;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct PoolRewardCustodianDfKey<phantom Ty0> has copy, drop, store {
dummy_field: bool
}
struct Pool<phantom Ty0, phantom Ty1> has store, key {
id: UID,
coin_type_x: TypeName,
coin_type_y: TypeName,
sqrt_price: u128,
tick_index: I32,
observation_index: u64,
observation_cardinality: u64,
observation_cardinality_next: u64,
tick_spacing: u32,
max_liquidity_per_tick: u128,
protocol_fee_rate: u64,
swap_fee_rate: u64,
fee_growth_global_x: u128,
fee_growth_global_y: u128,
protocol_fee_x: u64,
protocol_fee_y: u64,
liquidity: u128,
ticks: Table<I32, TickInfo>,
tick_bitmap: Table<I32, u256>,
observations: vector<Observation>,
locked: bool,
reward_infos: vector<PoolRewardInfo>,
reserve_x: Balance<Ty0>,
reserve_y: Balance<Ty1>
}
struct PoolRewardInfo has copy, drop, store {
reward_coin_type: TypeName,
last_update_time: u64,
ended_at_seconds: u64,
total_reward: u64,
total_reward_allocated: u64,
reward_per_seconds: u128,
reward_growth_global: u128
}
struct SwapState has copy, drop {
amount_specified_remaining: u64,
amount_calculated: u64,
sqrt_price: u128,
tick_index: I32,
fee_growth_global: u128,
protocol_fee: u64,
liquidity: u128,
fee_amount: u64
}
struct SwapStepComputations has copy, drop {
sqrt_price_start: u128,
tick_index_next: I32,
initialized: bool,
sqrt_price_next: u128,
amount_in: u64,
amount_out: u64,
fee_amount: u64
}
struct SwapReceipt {
pool_id: ID,
amount_x_debt: u64,
amount_y_debt: u64
}
struct FlashReceipt {
pool_id: ID,
amount_x: u64,
amount_y: u64,
fee_x: u64,
fee_y: u64
}
struct ModifyLiquidity has copy, drop, store {
sender: address,
pool_id: ID,
position_id: ID,
tick_lower_index: I32,
tick_upper_index: I32,
liquidity_delta: I128,
amount_x: u64,
amount_y: u64
}
struct Swap has copy, drop, store {
sender: address,
pool_id: ID,
x_for_y: bool,
amount_x: u64,
amount_y: u64,
sqrt_price_before: u128,
sqrt_price_after: u128,
liquidity: u128,
tick_index: I32,
fee_amount: u64
}
struct Flash has copy, drop, store {
sender: address,
pool_id: ID,
amount_x: u64,
amount_y: u64
}
struct Pay has copy, drop, store {
sender: address,
pool_id: ID,
amount_x_debt: u64,
amount_y_debt: u64,
paid_x: u64,
paid_y: u64
}
struct Collect has copy, drop, store {
sender: address,
pool_id: ID,
position_id: ID,
amount_x: u64,
amount_y: u64
}
struct CollectProtocolFee has copy, drop, store {
sender: address,
pool_id: ID,
amount_x: u64,
amount_y: u64
}
struct SetProtocolFeeRate has copy, drop, store {
sender: address,
pool_id: ID,
protocol_fee_rate_x_old: u64,
protocol_fee_rate_y_old: u64,
protocol_fee_rate_x_new: u64,
protocol_fee_rate_y_new: u64
}
struct Initialize has copy, drop, store {
sender: address,
pool_id: ID,
sqrt_price: u128,
tick_index: I32
}
struct IncreaseObservationCardinalityNext has copy, drop, store {
sender: address,
pool_id: ID,
observation_cardinality_next_old: u64,
observation_cardinality_next_new: u64
}
struct InitializePoolReward has copy, drop, store {
sender: address,
pool_id: ID,
reward_coin_type: TypeName,
started_at_seconds: u64
}
struct UpdatePoolRewardEmission has copy, drop, store {
sender: address,
pool_id: ID,
reward_coin_type: TypeName,
total_reward: u64,
ended_at_seconds: u64,
reward_per_seconds: u128
}
struct CollectPoolReward has copy, drop, store {
sender: address,
pool_id: ID,
position_id: ID,
reward_coin_type: TypeName,
amount: u64
}
public pool_id<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): ID {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
2Ret
}
public coin_type_x<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): TypeName {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[0](Pool.coin_type_x: TypeName)
2ReadRef
3Ret
}
public coin_type_y<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): TypeName {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[1](Pool.coin_type_y: TypeName)
2ReadRef
3Ret
}
public sqrt_price_current<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
2ReadRef
3Ret
}
public tick_index_current<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): I32 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
2ReadRef
3Ret
}
public observation_index<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[4](Pool.observation_index: u64)
2ReadRef
3Ret
}
public observation_cardinality<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
2ReadRef
3Ret
}
public observation_cardinality_next<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[6](Pool.observation_cardinality_next: u64)
2ReadRef
3Ret
}
public tick_spacing<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u32 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[7](Pool.tick_spacing: u32)
2ReadRef
3Ret
}
public max_liquidity_per_tick<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[8](Pool.max_liquidity_per_tick: u128)
2ReadRef
3Ret
}
public protocol_fee_rate<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[9](Pool.protocol_fee_rate: u64)
2ReadRef
3Ret
}
public swap_fee_rate<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[10](Pool.swap_fee_rate: u64)
2ReadRef
3Ret
}
public fee_growth_global_x<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
2ReadRef
3Ret
}
public fee_growth_global_y<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
2ReadRef
3Ret
}
public protocol_fee_x<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
2ReadRef
3Ret
}
public protocol_fee_y<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
2ReadRef
3Ret
}
public liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
2ReadRef
3Ret
}
public borrow_ticks<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &Table<I32, TickInfo> {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
2Ret
}
public borrow_tick_bitmap<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &Table<I32, u256> {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[17](Pool.tick_bitmap: Table<I32, u256>)
2Ret
}
public borrow_observations<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &vector<Observation> {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
2Ret
}
public is_locked<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[19](Pool.locked: bool)
2ReadRef
3Ret
}
public reward_length<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
2VecLen(51)
3Ret
}
public reward_info_at<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): &PoolRewardInfo {
B0:
0CopyLoc[1](Arg1: u64)
1CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
2Call reward_length<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64
3Ge
4BrFalse(9)
B1:
5MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
6Pop
7LdConst[11](u64: 11)
8Abort
B2:
9MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
10ImmBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
11MoveLoc[1](Arg1: u64)
12VecImmBorrow(51)
13Ret
}
public reward_coin_type<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): TypeName {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2Call reward_info_at<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): &PoolRewardInfo
3ImmBorrowField[21](PoolRewardInfo.reward_coin_type: TypeName)
4ReadRef
5Ret
}
public reward_last_update_at<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2Call reward_info_at<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): &PoolRewardInfo
3ImmBorrowField[22](PoolRewardInfo.last_update_time: u64)
4ReadRef
5Ret
}
public reward_ended_at<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2Call reward_info_at<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): &PoolRewardInfo
3ImmBorrowField[23](PoolRewardInfo.ended_at_seconds: u64)
4ReadRef
5Ret
}
public total_reward<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2Call reward_info_at<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): &PoolRewardInfo
3ImmBorrowField[24](PoolRewardInfo.total_reward: u64)
4ReadRef
5Ret
}
public total_reward_allocated<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u64 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2Call reward_info_at<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): &PoolRewardInfo
3ImmBorrowField[25](PoolRewardInfo.total_reward_allocated: u64)
4ReadRef
5Ret
}
public reward_per_seconds<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2Call reward_info_at<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): &PoolRewardInfo
3ImmBorrowField[26](PoolRewardInfo.reward_per_seconds: u128)
4ReadRef
5Ret
}
public reward_growth_global<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u128 {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1MoveLoc[1](Arg1: u64)
2Call reward_info_at<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): &PoolRewardInfo
3ImmBorrowField[27](PoolRewardInfo.reward_growth_global: u128)
4ReadRef
5Ret
}
public reserves<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[21](Pool.reserve_x: Balance<Ty0>)
2Call balance::value<Ty0>(&Balance<Ty0>): u64
3MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
4ImmBorrowFieldGeneric[22](Pool.reserve_y: Balance<Ty1>)
5Call balance::value<Ty1>(&Balance<Ty1>): u64
6Ret
}
public swap_receipt_debts(Arg0: &SwapReceipt): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &SwapReceipt)
1ImmBorrowField[30](SwapReceipt.amount_x_debt: u64)
2ReadRef
3MoveLoc[0](Arg0: &SwapReceipt)
4ImmBorrowField[31](SwapReceipt.amount_y_debt: u64)
5ReadRef
6Ret
}
public flash_receipt_debts(Arg0: &FlashReceipt): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &FlashReceipt)
1ImmBorrowField[32](FlashReceipt.amount_x: u64)
2ReadRef
3CopyLoc[0](Arg0: &FlashReceipt)
4ImmBorrowField[33](FlashReceipt.fee_x: u64)
5ReadRef
6Add
7CopyLoc[0](Arg0: &FlashReceipt)
8ImmBorrowField[34](FlashReceipt.amount_y: u64)
9ReadRef
10MoveLoc[0](Arg0: &FlashReceipt)
11ImmBorrowField[35](FlashReceipt.fee_y: u64)
12ReadRef
13Add
14Ret
}
public(friend) create<Ty0, Ty1>(Arg0: u64, Arg1: u32, Arg2: &mut TxContext): Pool<Ty0, Ty1> {
L3: loc0: UID
L4: loc1: Table<I32, TickInfo>
L5: loc2: Table<I32, u256>
L6: loc3: TypeName
L7: loc4: vector<Observation>
L8: loc5: vector<PoolRewardInfo>
L9: loc6: Balance<Ty0>
L10: loc7: Balance<Ty1>
L11: loc8: TypeName
L12: loc9: I32
L13: loc10: u32
L14: loc11: u128
L15: loc12: u64
B0:
0CopyLoc[2](Arg2: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[3](loc0: UID)
3Call type_name::get<Ty0>(): TypeName
4StLoc[6](loc3: TypeName)
5Call type_name::get<Ty1>(): TypeName
6StLoc[11](loc8: TypeName)
7Call i32::zero(): I32
8StLoc[12](loc9: I32)
9CopyLoc[1](Arg1: u32)
10StLoc[13](loc10: u32)
11MoveLoc[1](Arg1: u32)
12Call tick::tick_spacing_to_max_liquidity_per_tick(u32): u128
13StLoc[14](loc11: u128)
14MoveLoc[0](Arg0: u64)
15StLoc[15](loc12: u64)
16CopyLoc[2](Arg2: &mut TxContext)
17Call table::new<I32, TickInfo>(&mut TxContext): Table<I32, TickInfo>
18StLoc[4](loc1: Table<I32, TickInfo>)
19MoveLoc[2](Arg2: &mut TxContext)
20Call table::new<I32, u256>(&mut TxContext): Table<I32, u256>
21StLoc[5](loc2: Table<I32, u256>)
22VecPack(61, 0)
23StLoc[7](loc4: vector<Observation>)
24VecPack(51, 0)
25StLoc[8](loc5: vector<PoolRewardInfo>)
26Call balance::zero<Ty0>(): Balance<Ty0>
27StLoc[9](loc6: Balance<Ty0>)
28Call balance::zero<Ty1>(): Balance<Ty1>
29StLoc[10](loc7: Balance<Ty1>)
30MoveLoc[3](loc0: UID)
31MoveLoc[6](loc3: TypeName)
32MoveLoc[11](loc8: TypeName)
33LdU128(0)
34MoveLoc[12](loc9: I32)
35LdU64(0)
36LdU64(0)
37LdU64(0)
38MoveLoc[13](loc10: u32)
39MoveLoc[14](loc11: u128)
40LdU64(0)
41MoveLoc[15](loc12: u64)
42LdU128(0)
43LdU128(0)
44LdU64(0)
45LdU64(0)
46LdU128(0)
47MoveLoc[4](loc1: Table<I32, TickInfo>)
48MoveLoc[5](loc2: Table<I32, u256>)
49MoveLoc[7](loc4: vector<Observation>)
50LdTrue
51MoveLoc[8](loc5: vector<PoolRewardInfo>)
52MoveLoc[9](loc6: Balance<Ty0>)
53MoveLoc[10](loc7: Balance<Ty1>)
54PackGeneric[0](Pool<Ty0, Ty1>)
55Ret
}
public initialize<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u128, Arg2: &Versioned, Arg3: &Clock, Arg4: &TxContext) {
L5: loc0: u64
L6: loc1: I32
B0:
0CopyLoc[2](Arg2: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[2](Arg2: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
6ReadRef
7LdU128(0)
8Gt
9BrFalse(18)
B1:
10MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
11Pop
12MoveLoc[4](Arg4: &TxContext)
13Pop
14MoveLoc[3](Arg3: &Clock)
15Pop
16LdConst[2](u64: 2)
17Abort
B2:
18CopyLoc[1](Arg1: u128)
19Call tick_math::get_tick_at_sqrt_price(u128): I32
20StLoc[6](loc1: I32)
21CopyLoc[6](loc1: I32)
22CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
23MutBorrowFieldGeneric[3](Pool.tick_index: I32)
24WriteRef
25CopyLoc[1](Arg1: u128)
26CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
27MutBorrowFieldGeneric[2](Pool.sqrt_price: u128)
28WriteRef
29CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
30MutBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
31MoveLoc[3](Arg3: &Clock)
32Call clock::timestamp_ms(&Clock): u64
33Call utils::to_seconds(u64): u64
34Call oracle::initialize(&mut vector<Observation>, u64): u64 * u64
35StLoc[5](loc0: u64)
36CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
37MutBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
38WriteRef
39MoveLoc[5](loc0: u64)
40CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
41MutBorrowFieldGeneric[6](Pool.observation_cardinality_next: u64)
42WriteRef
43LdFalse
44CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
45MutBorrowFieldGeneric[19](Pool.locked: bool)
46WriteRef
47MoveLoc[4](Arg4: &TxContext)
48Call tx_context::sender(&TxContext): address
49MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
50FreezeRef
51Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
52MoveLoc[1](Arg1: u128)
53MoveLoc[6](loc1: I32)
54Pack[14](Initialize)
55Call event::emit<Initialize>(Initialize)
56Ret
}
public modify_liquidity<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut Position, Arg2: I128, Arg3: Balance<Ty0>, Arg4: Balance<Ty1>, Arg5: &Versioned, Arg6: &Clock, Arg7: &TxContext): u64 * u64 {
L8: loc0: ID
L9: loc1: bool
L10: loc2: bool
L11: loc3: bool
L12: loc4: u64
L13: loc5: u64
B0:
0CopyLoc[5](Arg5: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[5](Arg5: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8CopyLoc[1](Arg1: &mut Position)
9FreezeRef
10Call position::pool_id(&Position): ID
11StLoc[8](loc0: ID)
12FreezeRef
13MoveLoc[8](loc0: ID)
14Call check_pool_match<Ty0, Ty1>(&Pool<Ty0, Ty1>, ID)
15CopyLoc[2](Arg2: I128)
16Call i128::is_neg(I128): bool
17Not
18StLoc[11](loc3: bool)
19CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
20CopyLoc[1](Arg1: &mut Position)
21CopyLoc[2](Arg2: I128)
22MoveLoc[6](Arg6: &Clock)
23Call modify_position<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut Position, I128, &Clock): u64 * u64
24StLoc[13](loc5: u64)
25StLoc[12](loc4: u64)
26MoveLoc[11](loc3: bool)
27BrFalse(56)
B1:
28ImmBorrowLoc[3](Arg3: Balance<Ty0>)
29Call balance::value<Ty0>(&Balance<Ty0>): u64
30CopyLoc[12](loc4: u64)
31Lt
32BrFalse(36)
B2:
33LdTrue
34StLoc[9](loc1: bool)
35Branch(41)
B3:
36ImmBorrowLoc[4](Arg4: Balance<Ty1>)
37Call balance::value<Ty1>(&Balance<Ty1>): u64
38CopyLoc[13](loc5: u64)
39Lt
40StLoc[9](loc1: bool)
B4:
41MoveLoc[9](loc1: bool)
42BrFalse(51)
B5:
43MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
44Pop
45MoveLoc[1](Arg1: &mut Position)
46Pop
47MoveLoc[7](Arg7: &TxContext)
48Pop
49LdConst[1](u64: 1)
50Abort
B6:
51CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
52MoveLoc[3](Arg3: Balance<Ty0>)
53MoveLoc[4](Arg4: Balance<Ty1>)
54Call put<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>)
55Branch(77)
B7:
56MoveLoc[3](Arg3: Balance<Ty0>)
57Call balance::destroy_zero<Ty0>(Balance<Ty0>)
58MoveLoc[4](Arg4: Balance<Ty1>)
59Call balance::destroy_zero<Ty1>(Balance<Ty1>)
60CopyLoc[12](loc4: u64)
61LdU64(0)
62Gt
63BrFalse(67)
B8:
64LdTrue
65StLoc[10](loc2: bool)
66Branch(71)
B9:
67CopyLoc[13](loc5: u64)
68LdU64(0)
69Gt
70StLoc[10](loc2: bool)
B10:
71MoveLoc[10](loc2: bool)
72BrFalse(77)
B11:
73CopyLoc[1](Arg1: &mut Position)
74CopyLoc[12](loc4: u64)
75CopyLoc[13](loc5: u64)
76Call position::increase_debt(&mut Position, u64, u64)
B12:
77MoveLoc[7](Arg7: &TxContext)
78Call tx_context::sender(&TxContext): address
79MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
80FreezeRef
81Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
82CopyLoc[1](Arg1: &mut Position)
83FreezeRef
84Call object::id<Position>(&Position): ID
85CopyLoc[1](Arg1: &mut Position)
86FreezeRef
87Call position::tick_lower_index(&Position): I32
88MoveLoc[1](Arg1: &mut Position)
89FreezeRef
90Call position::tick_upper_index(&Position): I32
91MoveLoc[2](Arg2: I128)
92CopyLoc[12](loc4: u64)
93CopyLoc[13](loc5: u64)
94Pack[7](ModifyLiquidity)
95Call event::emit<ModifyLiquidity>(ModifyLiquidity)
96MoveLoc[12](loc4: u64)
97MoveLoc[13](loc5: u64)
98Ret
}
public swap<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: bool, Arg2: bool, Arg3: u64, Arg4: u128, Arg5: &Versioned, Arg6: &Clock, Arg7: &TxContext): Balance<Ty0> * Balance<Ty1> * SwapReceipt {
L8: loc0: u64
L9: loc1: Balance<Ty0>
L10: loc2: Balance<Ty1>
L11: loc3: SwapReceipt
L12: loc4: ID
L13: loc5: address
L14: loc6: bool
L15: loc7: u64
L16: loc8: u64
L17: loc9: u128
L18: loc10: u128
L19: loc11: u128
L20: loc12: u128
L21: loc13: I32
L22: loc14: u64
L23: loc15: bool
L24: loc16: u128
L25: loc17: u128
L26: loc18: u128
L27: loc19: I32
L28: loc20: u64
L29: loc21: u64
L30: loc22: u256
L31: loc23: u64
L32: loc24: u64
L33: loc25: u64
L34: loc26: u64
L35: loc27: bool
L36: loc28: u64
L37: loc29: u64
L38: loc30: u128
L39: loc31: u128
L40: loc32: u128
L41: loc33: bool
L42: loc34: I128
L43: loc35: u64
L44: loc36: u64
L45: loc37: u64
L46: loc38: SwapReceipt
L47: loc39: SwapReceipt
L48: loc40: SwapReceipt
L49: loc41: vector<u128>
L50: loc42: u256
L51: loc43: u128
L52: loc44: u128
L53: loc45: SwapState
L54: loc46: SwapStepComputations
L55: loc47: I64
L56: loc48: u64
L57: loc49: Balance<Ty0>
L58: loc50: Balance<Ty1>
B0:
0CopyLoc[5](Arg5: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[5](Arg5: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[1](Arg1: bool)
8BrFalse(36)
B1:
9CopyLoc[4](Arg4: u128)
10CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
11ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
12ReadRef
13Ge
14BrFalse(23)
B2:
15MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
16Pop
17MoveLoc[7](Arg7: &TxContext)
18Pop
19MoveLoc[6](Arg6: &Clock)
20Pop
21LdConst[4](u64: 4)
22Abort
B3:
23CopyLoc[4](Arg4: u128)
24Call tick_math::min_sqrt_price(): u128
25Le
26BrFalse(35)
B4:
27MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
28Pop
29MoveLoc[7](Arg7: &TxContext)
30Pop
31MoveLoc[6](Arg6: &Clock)
32Pop
33LdConst[5](u64: 5)
34Abort
B5:
35Branch(62)
B6:
36CopyLoc[4](Arg4: u128)
37CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
38ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
39ReadRef
40Le
41BrFalse(50)
B7:
42MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
43Pop
44MoveLoc[7](Arg7: &TxContext)
45Pop
46MoveLoc[6](Arg6: &Clock)
47Pop
48LdConst[4](u64: 4)
49Abort
B8:
50CopyLoc[4](Arg4: u128)
51Call tick_math::max_sqrt_price(): u128
52Ge
53BrFalse(62)
B9:
54MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
55Pop
56MoveLoc[7](Arg7: &TxContext)
57Pop
58MoveLoc[6](Arg6: &Clock)
59Pop
60LdConst[5](u64: 5)
61Abort
B10:
62LdTrue
63CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
64MutBorrowFieldGeneric[19](Pool.locked: bool)
65WriteRef
66CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
67ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
68ReadRef
69StLoc[51](loc43: u128)
70MoveLoc[6](Arg6: &Clock)
71Call clock::timestamp_ms(&Clock): u64
72Call utils::to_seconds(u64): u64
73LdFalse
74Call i64::zero(): I64
75LdU256(0)
76StLoc[50](loc42: u256)
77StLoc[55](loc47: I64)
78StLoc[35](loc27: bool)
79StLoc[56](loc48: u64)
80CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
81CopyLoc[56](loc48: u64)
82Call update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>
83StLoc[49](loc41: vector<u128>)
84CopyLoc[2](Arg2: bool)
85BrFalse(93)
B11:
86CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
87ImmBorrowFieldGeneric[9](Pool.protocol_fee_rate: u64)
88ReadRef
89LdU64(16)
90Mod
91StLoc[8](loc0: u64)
92Branch(99)
B12:
93CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
94ImmBorrowFieldGeneric[9](Pool.protocol_fee_rate: u64)
95ReadRef
96LdU8(4)
97Shr
98StLoc[8](loc0: u64)
B13:
99MoveLoc[8](loc0: u64)
100StLoc[45](loc37: u64)
101CopyLoc[1](Arg1: bool)
102BrFalse(108)
B14:
103CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
104ImmBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
105ReadRef
106StLoc[19](loc11: u128)
107Branch(112)
B15:
108CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
109ImmBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
110ReadRef
111StLoc[19](loc11: u128)
B16:
112MoveLoc[19](loc11: u128)
113StLoc[38](loc30: u128)
114CopyLoc[3](Arg3: u64)
115LdU64(0)
116CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
117ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
118ReadRef
119CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
120ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
121ReadRef
122MoveLoc[38](loc30: u128)
123LdU64(0)
124CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
125ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
126ReadRef
127LdU64(0)
128Pack[3](SwapState)
129StLoc[53](loc45: SwapState)
B17:
130ImmBorrowLoc[53](loc45: SwapState)
131ImmBorrowField[36](SwapState.amount_specified_remaining: u64)
132ReadRef
133LdU64(0)
134Neq
135BrFalse(144)
B18:
136Branch(137)
B19:
137ImmBorrowLoc[53](loc45: SwapState)
138ImmBorrowField[37](SwapState.sqrt_price: u128)
139ReadRef
140CopyLoc[4](Arg4: u128)
141Neq
142StLoc[23](loc15: bool)
143Branch(146)
B20:
144LdFalse
145StLoc[23](loc15: bool)
B21:
146MoveLoc[23](loc15: bool)
147BrFalse(491)
B22:
148LdU128(0)
149Call i32::zero(): I32
150LdFalse
151LdU128(0)
152LdU64(0)
153LdU64(0)
154LdU64(0)
155Pack[4](SwapStepComputations)
156StLoc[54](loc46: SwapStepComputations)
157ImmBorrowLoc[53](loc45: SwapState)
158ImmBorrowField[37](SwapState.sqrt_price: u128)
159ReadRef
160MutBorrowLoc[54](loc46: SwapStepComputations)
161MutBorrowField[38](SwapStepComputations.sqrt_price_start: u128)
162WriteRef
163CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
164ImmBorrowFieldGeneric[17](Pool.tick_bitmap: Table<I32, u256>)
165ImmBorrowLoc[53](loc45: SwapState)
166ImmBorrowField[39](SwapState.tick_index: I32)
167ReadRef
168CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
169ImmBorrowFieldGeneric[7](Pool.tick_spacing: u32)
170ReadRef
171CopyLoc[1](Arg1: bool)
172Call tick_bitmap::next_initialized_tick_within_one_word(&Table<I32, u256>, I32, u32, bool): I32 * bool
173StLoc[41](loc33: bool)
174MutBorrowLoc[54](loc46: SwapStepComputations)
175MutBorrowField[40](SwapStepComputations.tick_index_next: I32)
176WriteRef
177MoveLoc[41](loc33: bool)
178MutBorrowLoc[54](loc46: SwapStepComputations)
179MutBorrowField[41](SwapStepComputations.initialized: bool)
180WriteRef
181ImmBorrowLoc[54](loc46: SwapStepComputations)
182ImmBorrowField[40](SwapStepComputations.tick_index_next: I32)
183ReadRef
184Call tick_math::min_tick(): I32
185Call i32::lt(I32, I32): bool
186BrFalse(192)
B23:
187Call tick_math::min_tick(): I32
188MutBorrowLoc[54](loc46: SwapStepComputations)
189MutBorrowField[40](SwapStepComputations.tick_index_next: I32)
190WriteRef
191Branch(202)
B24:
192ImmBorrowLoc[54](loc46: SwapStepComputations)
193ImmBorrowField[40](SwapStepComputations.tick_index_next: I32)
194ReadRef
195Call tick_math::max_tick(): I32
196Call i32::gt(I32, I32): bool
197BrFalse(202)
B25:
198Call tick_math::max_tick(): I32
199MutBorrowLoc[54](loc46: SwapStepComputations)
200MutBorrowField[40](SwapStepComputations.tick_index_next: I32)
201WriteRef
B26:
202ImmBorrowLoc[54](loc46: SwapStepComputations)
203ImmBorrowField[40](SwapStepComputations.tick_index_next: I32)
204ReadRef
205Call tick_math::get_sqrt_price_at_tick(I32): u128
206MutBorrowLoc[54](loc46: SwapStepComputations)
207MutBorrowField[42](SwapStepComputations.sqrt_price_next: u128)
208WriteRef
209CopyLoc[1](Arg1: bool)
210BrFalse(218)
B27:
211ImmBorrowLoc[54](loc46: SwapStepComputations)
212ImmBorrowField[42](SwapStepComputations.sqrt_price_next: u128)
213ReadRef
214CopyLoc[4](Arg4: u128)
215Call full_math_u128::max(u128, u128): u128
216StLoc[24](loc16: u128)
217Branch(224)
B28:
218ImmBorrowLoc[54](loc46: SwapStepComputations)
219ImmBorrowField[42](SwapStepComputations.sqrt_price_next: u128)
220ReadRef
221CopyLoc[4](Arg4: u128)
222Call full_math_u128::min(u128, u128): u128
223StLoc[24](loc16: u128)
B29:
224MoveLoc[24](loc16: u128)
225StLoc[52](loc44: u128)
226ImmBorrowLoc[53](loc45: SwapState)
227ImmBorrowField[37](SwapState.sqrt_price: u128)
228ReadRef
229MoveLoc[52](loc44: u128)
230ImmBorrowLoc[53](loc45: SwapState)
231ImmBorrowField[43](SwapState.liquidity: u128)
232ReadRef
233ImmBorrowLoc[53](loc45: SwapState)
234ImmBorrowField[36](SwapState.amount_specified_remaining: u64)
235ReadRef
236CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
237ImmBorrowFieldGeneric[10](Pool.swap_fee_rate: u64)
238ReadRef
239CopyLoc[2](Arg2: bool)
240Call swap_math::compute_swap_step(u128, u128, u128, u64, u64, bool): u128 * u64 * u64 * u64
241StLoc[37](loc29: u64)
242StLoc[32](loc24: u64)
243StLoc[31](loc23: u64)
244MutBorrowLoc[53](loc45: SwapState)
245MutBorrowField[37](SwapState.sqrt_price: u128)
246WriteRef
247MoveLoc[31](loc23: u64)
248MutBorrowLoc[54](loc46: SwapStepComputations)
249MutBorrowField[44](SwapStepComputations.amount_in: u64)
250WriteRef
251MoveLoc[32](loc24: u64)
252MutBorrowLoc[54](loc46: SwapStepComputations)
253MutBorrowField[45](SwapStepComputations.amount_out: u64)
254WriteRef
255MoveLoc[37](loc29: u64)
256MutBorrowLoc[54](loc46: SwapStepComputations)
257MutBorrowField[46](SwapStepComputations.fee_amount: u64)
258WriteRef
259CopyLoc[2](Arg2: bool)
260BrFalse(286)
B30:
261ImmBorrowLoc[53](loc45: SwapState)
262ImmBorrowField[36](SwapState.amount_specified_remaining: u64)
263ReadRef
264ImmBorrowLoc[54](loc46: SwapStepComputations)
265ImmBorrowField[44](SwapStepComputations.amount_in: u64)
266ReadRef
267ImmBorrowLoc[54](loc46: SwapStepComputations)
268ImmBorrowField[46](SwapStepComputations.fee_amount: u64)
269ReadRef
270Add
271Sub
272MutBorrowLoc[53](loc45: SwapState)
273MutBorrowField[36](SwapState.amount_specified_remaining: u64)
274WriteRef
275ImmBorrowLoc[53](loc45: SwapState)
276ImmBorrowField[47](SwapState.amount_calculated: u64)
277ReadRef
278ImmBorrowLoc[54](loc46: SwapStepComputations)
279ImmBorrowField[45](SwapStepComputations.amount_out: u64)
280ReadRef
281Add
282MutBorrowLoc[53](loc45: SwapState)
283MutBorrowField[47](SwapState.amount_calculated: u64)
284WriteRef
285Branch(310)
B31:
286ImmBorrowLoc[53](loc45: SwapState)
287ImmBorrowField[36](SwapState.amount_specified_remaining: u64)
288ReadRef
289ImmBorrowLoc[54](loc46: SwapStepComputations)
290ImmBorrowField[45](SwapStepComputations.amount_out: u64)
291ReadRef
292Sub
293MutBorrowLoc[53](loc45: SwapState)
294MutBorrowField[36](SwapState.amount_specified_remaining: u64)
295WriteRef
296ImmBorrowLoc[53](loc45: SwapState)
297ImmBorrowField[47](SwapState.amount_calculated: u64)
298ReadRef
299ImmBorrowLoc[54](loc46: SwapStepComputations)
300ImmBorrowField[44](SwapStepComputations.amount_in: u64)
301ReadRef
302ImmBorrowLoc[54](loc46: SwapStepComputations)
303ImmBorrowField[46](SwapStepComputations.fee_amount: u64)
304ReadRef
305Add
306Add
307MutBorrowLoc[53](loc45: SwapState)
308MutBorrowField[47](SwapState.amount_calculated: u64)
309WriteRef
B32:
310CopyLoc[45](loc37: u64)
311LdU64(0)
312Gt
313BrFalse(336)
B33:
314ImmBorrowLoc[54](loc46: SwapStepComputations)
315ImmBorrowField[46](SwapStepComputations.fee_amount: u64)
316ReadRef
317CopyLoc[45](loc37: u64)
318Div
319StLoc[36](loc28: u64)
320ImmBorrowLoc[54](loc46: SwapStepComputations)
321ImmBorrowField[46](SwapStepComputations.fee_amount: u64)
322ReadRef
323CopyLoc[36](loc28: u64)
324Sub
325MutBorrowLoc[54](loc46: SwapStepComputations)
326MutBorrowField[46](SwapStepComputations.fee_amount: u64)
327WriteRef
328ImmBorrowLoc[53](loc45: SwapState)
329ImmBorrowField[48](SwapState.protocol_fee: u64)
330ReadRef
331MoveLoc[36](loc28: u64)
332Add
333MutBorrowLoc[53](loc45: SwapState)
334MutBorrowField[48](SwapState.protocol_fee: u64)
335WriteRef
B34:
336ImmBorrowLoc[53](loc45: SwapState)
337ImmBorrowField[43](SwapState.liquidity: u128)
338ReadRef
339LdU128(0)
340Gt
341BrFalse(359)
B35:
342ImmBorrowLoc[53](loc45: SwapState)
343ImmBorrowField[49](SwapState.fee_growth_global: u128)
344ReadRef
345ImmBorrowLoc[54](loc46: SwapStepComputations)
346ImmBorrowField[46](SwapStepComputations.fee_amount: u64)
347ReadRef
348CastU128
349Call constants::get_q64(): u128
350CastU128
351ImmBorrowLoc[53](loc45: SwapState)
352ImmBorrowField[43](SwapState.liquidity: u128)
353ReadRef
354Call full_math_u128::mul_div_floor(u128, u128, u128): u128
355Call full_math_u128::wrapping_add(u128, u128): u128
356MutBorrowLoc[53](loc45: SwapState)
357MutBorrowField[49](SwapState.fee_growth_global: u128)
358WriteRef
B36:
359ImmBorrowLoc[53](loc45: SwapState)
360ImmBorrowField[50](SwapState.fee_amount: u64)
361ReadRef
362ImmBorrowLoc[54](loc46: SwapStepComputations)
363ImmBorrowField[46](SwapStepComputations.fee_amount: u64)
364ReadRef
365Add
366MutBorrowLoc[53](loc45: SwapState)
367MutBorrowField[50](SwapState.fee_amount: u64)
368WriteRef
369ImmBorrowLoc[53](loc45: SwapState)
370ImmBorrowField[37](SwapState.sqrt_price: u128)
371ReadRef
372ImmBorrowLoc[54](loc46: SwapStepComputations)
373ImmBorrowField[42](SwapStepComputations.sqrt_price_next: u128)
374ReadRef
375Eq
376BrFalse(475)
B37:
377CopyLoc[1](Arg1: bool)
378BrFalse(388)
B38:
379ImmBorrowLoc[53](loc45: SwapState)
380ImmBorrowField[49](SwapState.fee_growth_global: u128)
381ReadRef
382CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
383ImmBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
384ReadRef
385StLoc[26](loc18: u128)
386StLoc[25](loc17: u128)
387Branch(396)
B39:
388CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
389ImmBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
390ReadRef
391ImmBorrowLoc[53](loc45: SwapState)
392ImmBorrowField[49](SwapState.fee_growth_global: u128)
393ReadRef
394StLoc[26](loc18: u128)
395StLoc[25](loc17: u128)
B40:
396MoveLoc[25](loc17: u128)
397MoveLoc[26](loc18: u128)
398StLoc[40](loc32: u128)
399StLoc[39](loc31: u128)
400ImmBorrowLoc[54](loc46: SwapStepComputations)
401ImmBorrowField[41](SwapStepComputations.initialized: bool)
402ReadRef
403BrFalse(456)
B41:
404CopyLoc[35](loc27: bool)
405Not
406BrFalse(430)
B42:
407LdTrue
408StLoc[35](loc27: bool)
409CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
410ImmBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
411CopyLoc[56](loc48: u64)
412LdU64(0)
413CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
414ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
415ReadRef
416CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
417ImmBorrowFieldGeneric[4](Pool.observation_index: u64)
418ReadRef
419CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
420ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
421ReadRef
422CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
423ImmBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
424ReadRef
425Call oracle::observe_single(&vector<Observation>, u64, u64, I32, u64, u128, u64): I64 * u256
426StLoc[30](loc22: u256)
427StLoc[55](loc47: I64)
428MoveLoc[30](loc22: u256)
429StLoc[50](loc42: u256)
B43:
430CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
431MutBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
432ImmBorrowLoc[54](loc46: SwapStepComputations)
433ImmBorrowField[40](SwapStepComputations.tick_index_next: I32)
434ReadRef
435MoveLoc[39](loc31: u128)
436MoveLoc[40](loc32: u128)
437CopyLoc[49](loc41: vector<u128>)
438CopyLoc[50](loc42: u256)
439CopyLoc[55](loc47: I64)
440CopyLoc[56](loc48: u64)
441Call tick::cross(&mut Table<I32, TickInfo>, I32, u128, u128, vector<u128>, u256, I64, u64): I128
442StLoc[42](loc34: I128)
443CopyLoc[1](Arg1: bool)
444BrFalse(448)
B44:
445MoveLoc[42](loc34: I128)
446Call i128::neg(I128): I128
447StLoc[42](loc34: I128)
B45:
448ImmBorrowLoc[53](loc45: SwapState)
449ImmBorrowField[43](SwapState.liquidity: u128)
450ReadRef
451MoveLoc[42](loc34: I128)
452Call liquidity_math::add_delta(u128, I128): u128
453MutBorrowLoc[53](loc45: SwapState)
454MutBorrowField[43](SwapState.liquidity: u128)
455WriteRef
B46:
456CopyLoc[1](Arg1: bool)
457BrFalse(466)
B47:
458ImmBorrowLoc[54](loc46: SwapStepComputations)
459ImmBorrowField[40](SwapStepComputations.tick_index_next: I32)
460ReadRef
461LdU32(1)
462Call i32::from(u32): I32
463Call i32::sub(I32, I32): I32
464StLoc[27](loc19: I32)
465Branch(470)
B48:
466ImmBorrowLoc[54](loc46: SwapStepComputations)
467ImmBorrowField[40](SwapStepComputations.tick_index_next: I32)
468ReadRef
469StLoc[27](loc19: I32)
B49:
470MoveLoc[27](loc19: I32)
471MutBorrowLoc[53](loc45: SwapState)
472MutBorrowField[39](SwapState.tick_index: I32)
473WriteRef
474Branch(490)
B50:
475ImmBorrowLoc[53](loc45: SwapState)
476ImmBorrowField[37](SwapState.sqrt_price: u128)
477ReadRef
478ImmBorrowLoc[54](loc46: SwapStepComputations)
479ImmBorrowField[38](SwapStepComputations.sqrt_price_start: u128)
480ReadRef
481Neq
482BrFalse(490)
B51:
483ImmBorrowLoc[53](loc45: SwapState)
484ImmBorrowField[37](SwapState.sqrt_price: u128)
485ReadRef
486Call tick_math::get_tick_at_sqrt_price(u128): I32
487MutBorrowLoc[53](loc45: SwapState)
488MutBorrowField[39](SwapState.tick_index: I32)
489WriteRef
B52:
490Branch(130)
B53:
491ImmBorrowLoc[53](loc45: SwapState)
492ImmBorrowField[39](SwapState.tick_index: I32)
493ReadRef
494CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
495ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
496ReadRef
497Call i32::eq(I32, I32): bool
498Not
499BrFalse(542)
B54:
500CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
501MutBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
502CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
503ImmBorrowFieldGeneric[4](Pool.observation_index: u64)
504ReadRef
505MoveLoc[56](loc48: u64)
506CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
507ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
508ReadRef
509CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
510ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
511ReadRef
512CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
513ImmBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
514ReadRef
515CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
516ImmBorrowFieldGeneric[6](Pool.observation_cardinality_next: u64)
517ReadRef
518Call oracle::write(&mut vector<Observation>, u64, u64, I32, u128, u64, u64): u64 * u64
519StLoc[43](loc35: u64)
520StLoc[44](loc36: u64)
521ImmBorrowLoc[53](loc45: SwapState)
522ImmBorrowField[37](SwapState.sqrt_price: u128)
523ReadRef
524CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
525MutBorrowFieldGeneric[2](Pool.sqrt_price: u128)
526WriteRef
527ImmBorrowLoc[53](loc45: SwapState)
528ImmBorrowField[39](SwapState.tick_index: I32)
529ReadRef
530CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
531MutBorrowFieldGeneric[3](Pool.tick_index: I32)
532WriteRef
533MoveLoc[44](loc36: u64)
534CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
535MutBorrowFieldGeneric[4](Pool.observation_index: u64)
536WriteRef
537MoveLoc[43](loc35: u64)
538CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
539MutBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
540WriteRef
541Branch(548)
B55:
542ImmBorrowLoc[53](loc45: SwapState)
543ImmBorrowField[37](SwapState.sqrt_price: u128)
544ReadRef
545CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
546MutBorrowFieldGeneric[2](Pool.sqrt_price: u128)
547WriteRef
B56:
548CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
549ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
550ReadRef
551ImmBorrowLoc[53](loc45: SwapState)
552ImmBorrowField[43](SwapState.liquidity: u128)
553ReadRef
554Neq
555BrFalse(562)
B57:
556ImmBorrowLoc[53](loc45: SwapState)
557ImmBorrowField[43](SwapState.liquidity: u128)
558ReadRef
559CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
560MutBorrowFieldGeneric[15](Pool.liquidity: u128)
561WriteRef
B58:
562CopyLoc[1](Arg1: bool)
563BrFalse(581)
B59:
564ImmBorrowLoc[53](loc45: SwapState)
565ImmBorrowField[49](SwapState.fee_growth_global: u128)
566ReadRef
567CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
568MutBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
569WriteRef
570CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
571ImmBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
572ReadRef
573ImmBorrowLoc[53](loc45: SwapState)
574ImmBorrowField[48](SwapState.protocol_fee: u64)
575ReadRef
576Add
577CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
578MutBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
579WriteRef
580Branch(597)
B60:
581ImmBorrowLoc[53](loc45: SwapState)
582ImmBorrowField[49](SwapState.fee_growth_global: u128)
583ReadRef
584CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
585MutBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
586WriteRef
587CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
588ImmBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
589ReadRef
590ImmBorrowLoc[53](loc45: SwapState)
591ImmBorrowField[48](SwapState.protocol_fee: u64)
592ReadRef
593Add
594CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
595MutBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
596WriteRef
B61:
597CopyLoc[1](Arg1: bool)
598MoveLoc[2](Arg2: bool)
599Eq
600BrFalse(612)
B62:
601MoveLoc[3](Arg3: u64)
602ImmBorrowLoc[53](loc45: SwapState)
603ImmBorrowField[36](SwapState.amount_specified_remaining: u64)
604ReadRef
605Sub
606ImmBorrowLoc[53](loc45: SwapState)
607ImmBorrowField[47](SwapState.amount_calculated: u64)
608ReadRef
609StLoc[29](loc21: u64)
610StLoc[28](loc20: u64)
611Branch(622)
B63:
612ImmBorrowLoc[53](loc45: SwapState)
613ImmBorrowField[47](SwapState.amount_calculated: u64)
614ReadRef
615MoveLoc[3](Arg3: u64)
616ImmBorrowLoc[53](loc45: SwapState)
617ImmBorrowField[36](SwapState.amount_specified_remaining: u64)
618ReadRef
619Sub
620StLoc[29](loc21: u64)
621StLoc[28](loc20: u64)
B64:
622MoveLoc[28](loc20: u64)
623MoveLoc[29](loc21: u64)
624StLoc[34](loc26: u64)
625StLoc[33](loc25: u64)
626CopyLoc[1](Arg1: bool)
627BrFalse(644)
B65:
628CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
629FreezeRef
630Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
631CopyLoc[33](loc25: u64)
632LdU64(0)
633Pack[5](SwapReceipt)
634StLoc[46](loc38: SwapReceipt)
635CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
636LdU64(0)
637CopyLoc[34](loc26: u64)
638Call take<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64): Balance<Ty0> * Balance<Ty1>
639MoveLoc[46](loc38: SwapReceipt)
640StLoc[11](loc3: SwapReceipt)
641StLoc[10](loc2: Balance<Ty1>)
642StLoc[9](loc1: Balance<Ty0>)
643Branch(659)
B66:
644CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
645FreezeRef
646Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
647LdU64(0)
648CopyLoc[34](loc26: u64)
649Pack[5](SwapReceipt)
650StLoc[47](loc39: SwapReceipt)
651CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
652CopyLoc[33](loc25: u64)
653LdU64(0)
654Call take<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64): Balance<Ty0> * Balance<Ty1>
655MoveLoc[47](loc39: SwapReceipt)
656StLoc[11](loc3: SwapReceipt)
657StLoc[10](loc2: Balance<Ty1>)
658StLoc[9](loc1: Balance<Ty0>)
B67:
659MoveLoc[9](loc1: Balance<Ty0>)
660MoveLoc[10](loc2: Balance<Ty1>)
661MoveLoc[11](loc3: SwapReceipt)
662StLoc[48](loc40: SwapReceipt)
663StLoc[58](loc50: Balance<Ty1>)
664StLoc[57](loc49: Balance<Ty0>)
665MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
666FreezeRef
667Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
668StLoc[12](loc4: ID)
669MoveLoc[7](Arg7: &TxContext)
670Call tx_context::sender(&TxContext): address
671StLoc[13](loc5: address)
672MoveLoc[1](Arg1: bool)
673StLoc[14](loc6: bool)
674MoveLoc[33](loc25: u64)
675StLoc[15](loc7: u64)
676MoveLoc[34](loc26: u64)
677StLoc[16](loc8: u64)
678MoveLoc[51](loc43: u128)
679StLoc[17](loc9: u128)
680ImmBorrowLoc[53](loc45: SwapState)
681ImmBorrowField[37](SwapState.sqrt_price: u128)
682ReadRef
683StLoc[18](loc10: u128)
684ImmBorrowLoc[53](loc45: SwapState)
685ImmBorrowField[43](SwapState.liquidity: u128)
686ReadRef
687StLoc[20](loc12: u128)
688ImmBorrowLoc[53](loc45: SwapState)
689ImmBorrowField[39](SwapState.tick_index: I32)
690ReadRef
691StLoc[21](loc13: I32)
692ImmBorrowLoc[53](loc45: SwapState)
693ImmBorrowField[50](SwapState.fee_amount: u64)
694ReadRef
695StLoc[22](loc14: u64)
696MoveLoc[13](loc5: address)
697MoveLoc[12](loc4: ID)
698MoveLoc[14](loc6: bool)
699MoveLoc[15](loc7: u64)
700MoveLoc[16](loc8: u64)
701MoveLoc[17](loc9: u128)
702MoveLoc[18](loc10: u128)
703MoveLoc[20](loc12: u128)
704MoveLoc[21](loc13: I32)
705MoveLoc[22](loc14: u64)
706Pack[8](Swap)
707Call event::emit<Swap>(Swap)
708MoveLoc[57](loc49: Balance<Ty0>)
709MoveLoc[58](loc50: Balance<Ty1>)
710MoveLoc[48](loc40: SwapReceipt)
711Ret
}
public pay<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: SwapReceipt, Arg2: Balance<Ty0>, Arg3: Balance<Ty1>, Arg4: &Versioned, Arg5: &TxContext) {
L6: loc0: ID
L7: loc1: bool
L8: loc2: u64
L9: loc3: u64
L10: loc4: u64
L11: loc5: u64
L12: loc6: u64
L13: loc7: u64
B0:
0CopyLoc[4](Arg4: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[4](Arg4: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5ImmBorrowLoc[1](Arg1: SwapReceipt)
6ImmBorrowField[51](SwapReceipt.pool_id: ID)
7ReadRef
8StLoc[6](loc0: ID)
9FreezeRef
10MoveLoc[6](loc0: ID)
11Call check_pool_match<Ty0, Ty1>(&Pool<Ty0, Ty1>, ID)
12MoveLoc[1](Arg1: SwapReceipt)
13Unpack[5](SwapReceipt)
14StLoc[9](loc3: u64)
15StLoc[8](loc2: u64)
16Pop
17CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
18FreezeRef
19Call reserves<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64 * u64
20StLoc[13](loc7: u64)
21StLoc[11](loc5: u64)
22CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
23MoveLoc[2](Arg2: Balance<Ty0>)
24MoveLoc[3](Arg3: Balance<Ty1>)
25Call put<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>)
26CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
27FreezeRef
28Call reserves<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64 * u64
29StLoc[12](loc6: u64)
30StLoc[10](loc4: u64)
31CopyLoc[11](loc5: u64)
32CopyLoc[8](loc2: u64)
33Add
34CopyLoc[10](loc4: u64)
35Gt
36BrFalse(40)
B1:
37LdTrue
38StLoc[7](loc1: bool)
39Branch(46)
B2:
40CopyLoc[13](loc7: u64)
41CopyLoc[9](loc3: u64)
42Add
43CopyLoc[12](loc6: u64)
44Gt
45StLoc[7](loc1: bool)
B3:
46MoveLoc[7](loc1: bool)
47BrFalse(54)
B4:
48MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
49Pop
50MoveLoc[5](Arg5: &TxContext)
51Pop
52LdConst[1](u64: 1)
53Abort
B5:
54LdFalse
55CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
56MutBorrowFieldGeneric[19](Pool.locked: bool)
57WriteRef
58MoveLoc[5](Arg5: &TxContext)
59Call tx_context::sender(&TxContext): address
60MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
61FreezeRef
62Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
63MoveLoc[8](loc2: u64)
64MoveLoc[9](loc3: u64)
65MoveLoc[10](loc4: u64)
66MoveLoc[11](loc5: u64)
67Sub
68MoveLoc[12](loc6: u64)
69MoveLoc[13](loc7: u64)
70Sub
71Pack[10](Pay)
72Call event::emit<Pay>(Pay)
73Ret
}
public flash<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: &Versioned, Arg4: &TxContext): Balance<Ty0> * Balance<Ty1> * FlashReceipt {
L5: loc0: u64
L6: loc1: u64
L7: loc2: Balance<Ty0>
L8: loc3: Balance<Ty1>
B0:
0CopyLoc[3](Arg3: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[3](Arg3: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7LdTrue
8CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
9MutBorrowFieldGeneric[19](Pool.locked: bool)
10WriteRef
11CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
12ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
13ReadRef
14LdU128(0)
15Eq
16BrFalse(23)
B1:
17MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
18Pop
19MoveLoc[4](Arg4: &TxContext)
20Pop
21LdConst[6](u64: 6)
22Abort
B2:
23CopyLoc[1](Arg1: u64)
24CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
25ImmBorrowFieldGeneric[10](Pool.swap_fee_rate: u64)
26ReadRef
27Call constants::get_fee_rate_denominator_value(): u64
28Call full_math_u64::mul_div_round(u64, u64, u64): u64
29CopyLoc[2](Arg2: u64)
30CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
31ImmBorrowFieldGeneric[10](Pool.swap_fee_rate: u64)
32ReadRef
33Call constants::get_fee_rate_denominator_value(): u64
34Call full_math_u64::mul_div_round(u64, u64, u64): u64
35StLoc[6](loc1: u64)
36StLoc[5](loc0: u64)
37CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
38MutBorrowFieldGeneric[21](Pool.reserve_x: Balance<Ty0>)
39CopyLoc[1](Arg1: u64)
40Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
41CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
42MutBorrowFieldGeneric[22](Pool.reserve_y: Balance<Ty1>)
43CopyLoc[2](Arg2: u64)
44Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
45StLoc[8](loc3: Balance<Ty1>)
46StLoc[7](loc2: Balance<Ty0>)
47MoveLoc[4](Arg4: &TxContext)
48Call tx_context::sender(&TxContext): address
49CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
50FreezeRef
51Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
52CopyLoc[1](Arg1: u64)
53CopyLoc[2](Arg2: u64)
54Pack[9](Flash)
55Call event::emit<Flash>(Flash)
56MoveLoc[7](loc2: Balance<Ty0>)
57MoveLoc[8](loc3: Balance<Ty1>)
58MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
59FreezeRef
60Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
61MoveLoc[1](Arg1: u64)
62MoveLoc[2](Arg2: u64)
63MoveLoc[5](loc0: u64)
64MoveLoc[6](loc1: u64)
65Pack[6](FlashReceipt)
66Ret
}
public repay<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: FlashReceipt, Arg2: Balance<Ty0>, Arg3: Balance<Ty1>, Arg4: &Versioned, Arg5: &TxContext) {
L6: loc0: ID
L7: loc1: bool
L8: loc2: u64
L9: loc3: u64
L10: loc4: u64
L11: loc5: u64
L12: loc6: u64
L13: loc7: u64
L14: loc8: u64
L15: loc9: u64
L16: loc10: u64
L17: loc11: u64
L18: loc12: u64
L19: loc13: u64
L20: loc14: u64
L21: loc15: u64
L22: loc16: u64
L23: loc17: u64
B0:
0CopyLoc[4](Arg4: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[4](Arg4: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5ImmBorrowLoc[1](Arg1: FlashReceipt)
6ImmBorrowField[52](FlashReceipt.pool_id: ID)
7ReadRef
8StLoc[6](loc0: ID)
9FreezeRef
10MoveLoc[6](loc0: ID)
11Call check_pool_match<Ty0, Ty1>(&Pool<Ty0, Ty1>, ID)
12MoveLoc[1](Arg1: FlashReceipt)
13Unpack[6](FlashReceipt)
14StLoc[18](loc12: u64)
15StLoc[16](loc10: u64)
16StLoc[11](loc5: u64)
17StLoc[10](loc4: u64)
18Pop
19CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
20FreezeRef
21Call reserves<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64 * u64
22StLoc[15](loc9: u64)
23StLoc[13](loc7: u64)
24CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
25MoveLoc[2](Arg2: Balance<Ty0>)
26MoveLoc[3](Arg3: Balance<Ty1>)
27Call put<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>)
28CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
29FreezeRef
30Call reserves<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64 * u64
31StLoc[14](loc8: u64)
32StLoc[12](loc6: u64)
33CopyLoc[13](loc7: u64)
34CopyLoc[10](loc4: u64)
35CopyLoc[16](loc10: u64)
36Add
37Add
38CopyLoc[12](loc6: u64)
39Gt
40BrFalse(44)
B1:
41LdTrue
42StLoc[7](loc1: bool)
43Branch(52)
B2:
44CopyLoc[15](loc9: u64)
45CopyLoc[11](loc5: u64)
46CopyLoc[18](loc12: u64)
47Add
48Add
49CopyLoc[14](loc8: u64)
50Gt
51StLoc[7](loc1: bool)
B3:
52MoveLoc[7](loc1: bool)
53BrFalse(60)
B4:
54MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
55Pop
56MoveLoc[5](Arg5: &TxContext)
57Pop
58LdConst[1](u64: 1)
59Abort
B5:
60MoveLoc[12](loc6: u64)
61MoveLoc[13](loc7: u64)
62CopyLoc[10](loc4: u64)
63Add
64Sub
65StLoc[20](loc14: u64)
66MoveLoc[14](loc8: u64)
67MoveLoc[15](loc9: u64)
68CopyLoc[11](loc5: u64)
69Add
70Sub
71StLoc[21](loc15: u64)
72CopyLoc[20](loc14: u64)
73LdU64(0)
74Gt
75BrFalse(120)
B6:
76CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
77ImmBorrowFieldGeneric[9](Pool.protocol_fee_rate: u64)
78ReadRef
79LdU64(16)
80Mod
81StLoc[22](loc16: u64)
82CopyLoc[22](loc16: u64)
83LdU64(0)
84Eq
85BrFalse(89)
B7:
86LdU64(0)
87StLoc[8](loc2: u64)
88Branch(93)
B8:
89CopyLoc[20](loc14: u64)
90MoveLoc[22](loc16: u64)
91Div
92StLoc[8](loc2: u64)
B9:
93MoveLoc[8](loc2: u64)
94StLoc[17](loc11: u64)
95CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
96ImmBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
97ReadRef
98CopyLoc[17](loc11: u64)
99Add
100CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
101MutBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
102WriteRef
103CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
104ImmBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
105ReadRef
106CopyLoc[20](loc14: u64)
107MoveLoc[17](loc11: u64)
108Sub
109CastU128
110Call constants::get_q64(): u128
111CastU128
112CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
113ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
114ReadRef
115Call full_math_u128::mul_div_floor(u128, u128, u128): u128
116Call full_math_u128::wrapping_add(u128, u128): u128
117CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
118MutBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
119WriteRef
B10:
120CopyLoc[21](loc15: u64)
121LdU64(0)
122Gt
123BrFalse(168)
B11:
124CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
125ImmBorrowFieldGeneric[9](Pool.protocol_fee_rate: u64)
126ReadRef
127LdU8(4)
128Shr
129StLoc[23](loc17: u64)
130CopyLoc[23](loc17: u64)
131LdU64(0)
132Eq
133BrFalse(137)
B12:
134LdU64(0)
135StLoc[9](loc3: u64)
136Branch(141)
B13:
137CopyLoc[21](loc15: u64)
138MoveLoc[23](loc17: u64)
139Div
140StLoc[9](loc3: u64)
B14:
141MoveLoc[9](loc3: u64)
142StLoc[19](loc13: u64)
143CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
144ImmBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
145ReadRef
146CopyLoc[19](loc13: u64)
147Add
148CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
149MutBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
150WriteRef
151CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
152ImmBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
153ReadRef
154CopyLoc[21](loc15: u64)
155MoveLoc[19](loc13: u64)
156Sub
157CastU128
158Call constants::get_q64(): u128
159CastU128
160CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
161ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
162ReadRef
163Call full_math_u128::mul_div_floor(u128, u128, u128): u128
164Call full_math_u128::wrapping_add(u128, u128): u128
165CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
166MutBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
167WriteRef
B15:
168LdFalse
169CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
170MutBorrowFieldGeneric[19](Pool.locked: bool)
171WriteRef
172MoveLoc[5](Arg5: &TxContext)
173Call tx_context::sender(&TxContext): address
174MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
175FreezeRef
176Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
177MoveLoc[10](loc4: u64)
178MoveLoc[16](loc10: u64)
179Add
180MoveLoc[11](loc5: u64)
181MoveLoc[18](loc12: u64)
182Add
183MoveLoc[20](loc14: u64)
184MoveLoc[21](loc15: u64)
185Pack[10](Pay)
186Call event::emit<Pay>(Pay)
187Ret
}
public collect<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut Position, Arg2: u64, Arg3: u64, Arg4: &Versioned, Arg5: &TxContext): Balance<Ty0> * Balance<Ty1> {
L6: loc0: ID
L7: loc1: u64
L8: loc2: u64
B0:
0CopyLoc[4](Arg4: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[4](Arg4: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8CopyLoc[1](Arg1: &mut Position)
9FreezeRef
10Call position::pool_id(&Position): ID
11StLoc[6](loc0: ID)
12FreezeRef
13MoveLoc[6](loc0: ID)
14Call check_pool_match<Ty0, Ty1>(&Pool<Ty0, Ty1>, ID)
15MoveLoc[2](Arg2: u64)
16CopyLoc[1](Arg1: &mut Position)
17FreezeRef
18Call position::coins_owed_x(&Position): u64
19Call math::min(u64, u64): u64
20StLoc[7](loc1: u64)
21MoveLoc[3](Arg3: u64)
22CopyLoc[1](Arg1: &mut Position)
23FreezeRef
24Call position::coins_owed_y(&Position): u64
25Call math::min(u64, u64): u64
26StLoc[8](loc2: u64)
27CopyLoc[1](Arg1: &mut Position)
28CopyLoc[7](loc1: u64)
29CopyLoc[8](loc2: u64)
30Call position::decrease_debt(&mut Position, u64, u64)
31MoveLoc[5](Arg5: &TxContext)
32Call tx_context::sender(&TxContext): address
33CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
34FreezeRef
35Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
36MoveLoc[1](Arg1: &mut Position)
37FreezeRef
38Call object::id<Position>(&Position): ID
39CopyLoc[7](loc1: u64)
40CopyLoc[8](loc2: u64)
41Pack[11](Collect)
42Call event::emit<Collect>(Collect)
43MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
44MoveLoc[7](loc1: u64)
45MoveLoc[8](loc2: u64)
46Call take<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64): Balance<Ty0> * Balance<Ty1>
47Ret
}
public collect_protocol_fee<Ty0, Ty1>(Arg0: &AdminCap, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: u64, Arg4: &Versioned, Arg5: &TxContext): Balance<Ty0> * Balance<Ty1> {
L6: loc0: u64
L7: loc1: u64
B0:
0CopyLoc[4](Arg4: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[4](Arg4: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7MoveLoc[2](Arg2: u64)
8CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
9ImmBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
10ReadRef
11Call math::min(u64, u64): u64
12StLoc[6](loc0: u64)
13MoveLoc[3](Arg3: u64)
14CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
15ImmBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
16ReadRef
17Call math::min(u64, u64): u64
18StLoc[7](loc1: u64)
19CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
20ImmBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
21ReadRef
22CopyLoc[6](loc0: u64)
23Sub
24CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
25MutBorrowFieldGeneric[13](Pool.protocol_fee_x: u64)
26WriteRef
27CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
28ImmBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
29ReadRef
30CopyLoc[7](loc1: u64)
31Sub
32CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
33MutBorrowFieldGeneric[14](Pool.protocol_fee_y: u64)
34WriteRef
35MoveLoc[5](Arg5: &TxContext)
36Call tx_context::sender(&TxContext): address
37CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
38FreezeRef
39Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
40CopyLoc[6](loc0: u64)
41CopyLoc[7](loc1: u64)
42Pack[12](CollectProtocolFee)
43Call event::emit<CollectProtocolFee>(CollectProtocolFee)
44MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
45MoveLoc[6](loc0: u64)
46MoveLoc[7](loc1: u64)
47Call take<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64): Balance<Ty0> * Balance<Ty1>
48Ret
}
public collect_pool_reward<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut Position, Arg2: u64, Arg3: &Versioned, Arg4: &TxContext): Balance<Ty2> {
L5: loc0: ID
L6: loc1: &mut Position
L7: loc2: u64
L8: loc3: u64
L9: loc4: u64
L10: loc5: ID
L11: loc6: u64
B0:
0CopyLoc[3](Arg3: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[3](Arg3: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8CopyLoc[1](Arg1: &mut Position)
9FreezeRef
10Call position::pool_id(&Position): ID
11StLoc[5](loc0: ID)
12FreezeRef
13MoveLoc[5](loc0: ID)
14Call check_pool_match<Ty0, Ty1>(&Pool<Ty0, Ty1>, ID)
15CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
16FreezeRef
17Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
18StLoc[10](loc5: ID)
19CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
20FreezeRef
21Call find_reward_info_index<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1>): u64
22StLoc[11](loc6: u64)
23MoveLoc[2](Arg2: u64)
24StLoc[8](loc3: u64)
25CopyLoc[1](Arg1: &mut Position)
26CopyLoc[11](loc6: u64)
27StLoc[7](loc2: u64)
28StLoc[6](loc1: &mut Position)
29MoveLoc[8](loc3: u64)
30MoveLoc[6](loc1: &mut Position)
31FreezeRef
32MoveLoc[7](loc2: u64)
33Call position::coins_owed_reward(&Position, u64): u64
34Call math::min(u64, u64): u64
35StLoc[9](loc4: u64)
36CopyLoc[1](Arg1: &mut Position)
37MoveLoc[11](loc6: u64)
38CopyLoc[9](loc4: u64)
39Call position::decrease_reward_debt(&mut Position, u64, u64)
40MoveLoc[4](Arg4: &TxContext)
41Call tx_context::sender(&TxContext): address
42MoveLoc[10](loc5: ID)
43MoveLoc[1](Arg1: &mut Position)
44FreezeRef
45Call object::id<Position>(&Position): ID
46Call type_name::get<Ty2>(): TypeName
47CopyLoc[9](loc4: u64)
48Pack[18](CollectPoolReward)
49Call event::emit<CollectPoolReward>(CollectPoolReward)
50MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
51MutBorrowFieldGeneric[23](Pool.id: UID)
52LdFalse
53PackGeneric[1](PoolRewardCustodianDfKey<Ty2>)
54Call dynamic_field::borrow_mut<PoolRewardCustodianDfKey<Ty2>, Balance<Ty2>>(&mut UID, PoolRewardCustodianDfKey<Ty2>): &mut Balance<Ty2>
55MoveLoc[9](loc4: u64)
56Call safe_withdraw<Ty2>(&mut Balance<Ty2>, u64): Balance<Ty2>
57Ret
}
public set_protocol_fee_rate<Ty0, Ty1>(Arg0: &AdminCap, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: u64, Arg4: &Versioned, Arg5: &TxContext) {
L6: loc0: bool
L7: loc1: bool
L8: loc2: bool
L9: loc3: bool
L10: loc4: bool
L11: loc5: u64
B0:
0CopyLoc[4](Arg4: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[4](Arg4: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[2](Arg2: u64)
8LdU64(0)
9Neq
10BrFalse(25)
B1:
11CopyLoc[2](Arg2: u64)
12LdU64(4)
13Lt
14BrFalse(18)
B2:
15LdTrue
16StLoc[10](loc4: bool)
17Branch(22)
B3:
18CopyLoc[2](Arg2: u64)
19LdU64(10)
20Gt
21StLoc[10](loc4: bool)
B4:
22MoveLoc[10](loc4: bool)
23StLoc[9](loc3: bool)
24Branch(27)
B5:
25LdFalse
26StLoc[9](loc3: bool)
B6:
27MoveLoc[9](loc3: bool)
28BrFalse(32)
B7:
29LdTrue
30StLoc[6](loc0: bool)
31Branch(54)
B8:
32CopyLoc[3](Arg3: u64)
33LdU64(0)
34Neq
35BrFalse(50)
B9:
36CopyLoc[3](Arg3: u64)
37LdU64(4)
38Lt
39BrFalse(43)
B10:
40LdTrue
41StLoc[8](loc2: bool)
42Branch(47)
B11:
43CopyLoc[3](Arg3: u64)
44LdU64(10)
45Gt
46StLoc[8](loc2: bool)
B12:
47MoveLoc[8](loc2: bool)
48StLoc[7](loc1: bool)
49Branch(52)
B13:
50LdFalse
51StLoc[7](loc1: bool)
B14:
52MoveLoc[7](loc1: bool)
53StLoc[6](loc0: bool)
B15:
54MoveLoc[6](loc0: bool)
55BrFalse(62)
B16:
56MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
57Pop
58MoveLoc[5](Arg5: &TxContext)
59Pop
60LdConst[7](u64: 7)
61Abort
B17:
62CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
63ImmBorrowFieldGeneric[9](Pool.protocol_fee_rate: u64)
64ReadRef
65StLoc[11](loc5: u64)
66CopyLoc[2](Arg2: u64)
67CopyLoc[3](Arg3: u64)
68LdU8(4)
69Shl
70Add
71CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
72MutBorrowFieldGeneric[9](Pool.protocol_fee_rate: u64)
73WriteRef
74MoveLoc[5](Arg5: &TxContext)
75Call tx_context::sender(&TxContext): address
76MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
77FreezeRef
78Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
79CopyLoc[11](loc5: u64)
80LdU64(16)
81Mod
82MoveLoc[11](loc5: u64)
83LdU8(4)
84Shr
85MoveLoc[2](Arg2: u64)
86MoveLoc[3](Arg3: u64)
87Pack[13](SetProtocolFeeRate)
88Call event::emit<SetProtocolFeeRate>(SetProtocolFeeRate)
89Ret
}
public increase_observation_cardinality_next<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: &Versioned, Arg3: &TxContext) {
L4: loc0: u64
L5: loc1: u64
B0:
0CopyLoc[2](Arg2: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[2](Arg2: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8ImmBorrowFieldGeneric[6](Pool.observation_cardinality_next: u64)
9ReadRef
10StLoc[5](loc1: u64)
11CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
12MutBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
13CopyLoc[5](loc1: u64)
14MoveLoc[1](Arg1: u64)
15Call oracle::grow(&mut vector<Observation>, u64, u64): u64
16StLoc[4](loc0: u64)
17CopyLoc[4](loc0: u64)
18CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
19MutBorrowFieldGeneric[6](Pool.observation_cardinality_next: u64)
20WriteRef
21MoveLoc[3](Arg3: &TxContext)
22Call tx_context::sender(&TxContext): address
23MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
24FreezeRef
25Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
26MoveLoc[5](loc1: u64)
27MoveLoc[4](loc0: u64)
28Pack[15](IncreaseObservationCardinalityNext)
29Call event::emit<IncreaseObservationCardinalityNext>(IncreaseObservationCardinalityNext)
30Ret
}
public snapshot_cumulatives_inside<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32, Arg3: &Clock): I64 * u256 * u64 {
L4: loc0: bool
L5: loc1: I64
L6: loc2: u256
L7: loc3: u64
L8: loc4: I64
L9: loc5: u256
L10: loc6: u64
L11: loc7: u64
L12: loc8: u64
L13: loc9: u256
L14: loc10: u256
L15: loc11: u256
L16: loc12: I64
L17: loc13: I64
L18: loc14: u64
B0:
0CopyLoc[1](Arg1: I32)
1CopyLoc[2](Arg2: I32)
2CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
3ImmBorrowFieldGeneric[7](Pool.tick_spacing: u32)
4ReadRef
5Call tick::check_ticks(I32, I32, u32)
6CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
8CopyLoc[1](Arg1: I32)
9Call tick::is_initialized(&Table<I32, TickInfo>, I32): bool
10Not
11BrFalse(15)
B1:
12LdTrue
13StLoc[4](loc0: bool)
14Branch(21)
B2:
15CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
16ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
17CopyLoc[2](Arg2: I32)
18Call tick::is_initialized(&Table<I32, TickInfo>, I32): bool
19Not
20StLoc[4](loc0: bool)
B3:
21MoveLoc[4](loc0: bool)
22BrFalse(29)
B4:
23MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
24Pop
25MoveLoc[3](Arg3: &Clock)
26Pop
27LdConst[8](u64: 8)
28Abort
B5:
29CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
30ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
31CopyLoc[1](Arg1: I32)
32Call tick::get_tick_cumulative_out_side(&Table<I32, TickInfo>, I32): I64
33CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
34ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
35CopyLoc[2](Arg2: I32)
36Call tick::get_tick_cumulative_out_side(&Table<I32, TickInfo>, I32): I64
37StLoc[17](loc13: I64)
38StLoc[16](loc12: I64)
39CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
40ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
41CopyLoc[1](Arg1: I32)
42Call tick::get_seconds_per_liquidity_out_side(&Table<I32, TickInfo>, I32): u256
43CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
44ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
45CopyLoc[2](Arg2: I32)
46Call tick::get_seconds_per_liquidity_out_side(&Table<I32, TickInfo>, I32): u256
47StLoc[15](loc11: u256)
48StLoc[14](loc10: u256)
49CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
50ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
51CopyLoc[1](Arg1: I32)
52Call tick::get_seconds_out_side(&Table<I32, TickInfo>, I32): u64
53CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
54ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
55CopyLoc[2](Arg2: I32)
56Call tick::get_seconds_out_side(&Table<I32, TickInfo>, I32): u64
57StLoc[12](loc8: u64)
58StLoc[11](loc7: u64)
59CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
60ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
61ReadRef
62MoveLoc[1](Arg1: I32)
63Call i32::lt(I32, I32): bool
64BrFalse(82)
B6:
65MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
66Pop
67MoveLoc[3](Arg3: &Clock)
68Pop
69MoveLoc[16](loc12: I64)
70MoveLoc[17](loc13: I64)
71Call i64::sub(I64, I64): I64
72MoveLoc[14](loc10: u256)
73MoveLoc[15](loc11: u256)
74Sub
75MoveLoc[11](loc7: u64)
76MoveLoc[12](loc8: u64)
77Sub
78StLoc[10](loc6: u64)
79StLoc[9](loc5: u256)
80StLoc[8](loc4: I64)
81Branch(150)
B7:
82CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
83ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
84ReadRef
85MoveLoc[2](Arg2: I32)
86Call i32::lt(I32, I32): bool
87BrFalse(128)
B8:
88MoveLoc[3](Arg3: &Clock)
89Call clock::timestamp_ms(&Clock): u64
90Call utils::to_seconds(u64): u64
91StLoc[18](loc14: u64)
92CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
93ImmBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
94CopyLoc[18](loc14: u64)
95LdU64(0)
96CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
97ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
98ReadRef
99CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
100ImmBorrowFieldGeneric[4](Pool.observation_index: u64)
101ReadRef
102CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
103ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
104ReadRef
105MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
106ImmBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
107ReadRef
108Call oracle::observe_single(&vector<Observation>, u64, u64, I32, u64, u128, u64): I64 * u256
109StLoc[13](loc9: u256)
110MoveLoc[16](loc12: I64)
111Call i64::sub(I64, I64): I64
112MoveLoc[17](loc13: I64)
113Call i64::sub(I64, I64): I64
114MoveLoc[13](loc9: u256)
115MoveLoc[14](loc10: u256)
116Sub
117MoveLoc[15](loc11: u256)
118Sub
119MoveLoc[18](loc14: u64)
120MoveLoc[11](loc7: u64)
121Sub
122MoveLoc[12](loc8: u64)
123Sub
124StLoc[7](loc3: u64)
125StLoc[6](loc2: u256)
126StLoc[5](loc1: I64)
127Branch(144)
B9:
128MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
129Pop
130MoveLoc[3](Arg3: &Clock)
131Pop
132MoveLoc[17](loc13: I64)
133MoveLoc[16](loc12: I64)
134Call i64::sub(I64, I64): I64
135MoveLoc[15](loc11: u256)
136MoveLoc[14](loc10: u256)
137Sub
138MoveLoc[12](loc8: u64)
139MoveLoc[11](loc7: u64)
140Sub
141StLoc[7](loc3: u64)
142StLoc[6](loc2: u256)
143StLoc[5](loc1: I64)
B10:
144MoveLoc[5](loc1: I64)
145MoveLoc[6](loc2: u256)
146MoveLoc[7](loc3: u64)
147StLoc[10](loc6: u64)
148StLoc[9](loc5: u256)
149StLoc[8](loc4: I64)
B11:
150MoveLoc[8](loc4: I64)
151MoveLoc[9](loc5: u256)
152MoveLoc[10](loc6: u64)
153Ret
}
public observe<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: vector<u64>, Arg2: &Clock): vector<I64> * vector<u256> {
B0:
0CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
2MoveLoc[2](Arg2: &Clock)
3Call clock::timestamp_ms(&Clock): u64
4Call utils::to_seconds(u64): u64
5MoveLoc[1](Arg1: vector<u64>)
6CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
7ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
8ReadRef
9CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
10ImmBorrowFieldGeneric[4](Pool.observation_index: u64)
11ReadRef
12CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
13ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
14ReadRef
15MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
16ImmBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
17ReadRef
18Call oracle::observe(&vector<Observation>, u64, vector<u64>, I32, u64, u128, u64): vector<I64> * vector<u256>
19Ret
}
public initialize_pool_reward<Ty0, Ty1, Ty2>(Arg0: &AdminCap, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: u64, Arg4: Balance<Ty2>, Arg5: &Versioned, Arg6: &Clock, Arg7: &TxContext) {
L8: loc0: TypeName
L9: loc1: u64
L10: loc2: u64
L11: loc3: TypeName
L12: loc4: PoolRewardInfo
B0:
0CopyLoc[5](Arg5: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[5](Arg5: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7MoveLoc[6](Arg6: &Clock)
8Call clock::timestamp_ms(&Clock): u64
9Call utils::to_seconds(u64): u64
10StLoc[10](loc2: u64)
11CopyLoc[2](Arg2: u64)
12MoveLoc[10](loc2: u64)
13Le
14BrFalse(21)
B1:
15MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16Pop
17MoveLoc[7](Arg7: &TxContext)
18Pop
19LdConst[9](u64: 9)
20Abort
B2:
21Call type_name::get<Ty2>(): TypeName
22StLoc[11](loc3: TypeName)
23CopyLoc[11](loc3: TypeName)
24StLoc[8](loc0: TypeName)
25CopyLoc[2](Arg2: u64)
26StLoc[9](loc1: u64)
27MoveLoc[8](loc0: TypeName)
28MoveLoc[9](loc1: u64)
29LdU64(0)
30LdU64(0)
31LdU64(0)
32LdU128(0)
33LdU128(0)
34Pack[2](PoolRewardInfo)
35StLoc[12](loc4: PoolRewardInfo)
36CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
37MutBorrowFieldGeneric[23](Pool.id: UID)
38LdFalse
39PackGeneric[1](PoolRewardCustodianDfKey<Ty2>)
40Call balance::zero<Ty2>(): Balance<Ty2>
41Call dynamic_field::add<PoolRewardCustodianDfKey<Ty2>, Balance<Ty2>>(&mut UID, PoolRewardCustodianDfKey<Ty2>, Balance<Ty2>)
42CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
43MutBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
44MoveLoc[12](loc4: PoolRewardInfo)
45VecPushBack(51)
46CopyLoc[7](Arg7: &TxContext)
47Call tx_context::sender(&TxContext): address
48CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
49FreezeRef
50Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
51MoveLoc[11](loc3: TypeName)
52MoveLoc[2](Arg2: u64)
53Pack[16](InitializePoolReward)
54Call event::emit<InitializePoolReward>(InitializePoolReward)
55MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
56MoveLoc[4](Arg4: Balance<Ty2>)
57MoveLoc[3](Arg3: u64)
58MoveLoc[7](Arg7: &TxContext)
59Call update_pool_reward_emission<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, Balance<Ty2>, u64, &TxContext)
60Ret
}
public increase_pool_reward<Ty0, Ty1, Ty2>(Arg0: &AdminCap, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty2>, Arg3: &Versioned, Arg4: &Clock, Arg5: &TxContext) {
B0:
0CopyLoc[3](Arg3: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[3](Arg3: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8MoveLoc[4](Arg4: &Clock)
9Call clock::timestamp_ms(&Clock): u64
10Call utils::to_seconds(u64): u64
11Call update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>
12Pop
13MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
14MoveLoc[2](Arg2: Balance<Ty2>)
15LdU64(0)
16MoveLoc[5](Arg5: &TxContext)
17Call update_pool_reward_emission<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, Balance<Ty2>, u64, &TxContext)
18Ret
}
public extend_pool_reward_timestamp<Ty0, Ty1, Ty2>(Arg0: &AdminCap, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: &Versioned, Arg4: &Clock, Arg5: &TxContext) {
B0:
0CopyLoc[3](Arg3: &Versioned)
1Call versioned::check_version(&Versioned)
2MoveLoc[3](Arg3: &Versioned)
3Call versioned::check_pause(&Versioned)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call check_lock<Ty0, Ty1>(&Pool<Ty0, Ty1>)
7CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
8MoveLoc[4](Arg4: &Clock)
9Call clock::timestamp_ms(&Clock): u64
10Call utils::to_seconds(u64): u64
11Call update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>
12Pop
13MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
14Call balance::zero<Ty2>(): Balance<Ty2>
15MoveLoc[2](Arg2: u64)
16MoveLoc[5](Arg5: &TxContext)
17Call update_pool_reward_emission<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, Balance<Ty2>, u64, &TxContext)
18Ret
}
update_pool_reward_emission<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Balance<Ty2>, Arg2: u64, Arg3: &TxContext) {
L4: loc0: u64
L5: loc1: ID
L6: loc2: &mut PoolRewardInfo
L7: loc3: u64
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1FreezeRef
2Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
3StLoc[5](loc1: ID)
4CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5FreezeRef
6Call find_reward_info_index<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1>): u64
7StLoc[7](loc3: u64)
8CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
9MutBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
10MoveLoc[7](loc3: u64)
11VecMutBorrow(51)
12StLoc[6](loc2: &mut PoolRewardInfo)
13CopyLoc[6](loc2: &mut PoolRewardInfo)
14ImmBorrowField[23](PoolRewardInfo.ended_at_seconds: u64)
15ReadRef
16MoveLoc[2](Arg2: u64)
17Add
18StLoc[4](loc0: u64)
19CopyLoc[4](loc0: u64)
20CopyLoc[6](loc2: &mut PoolRewardInfo)
21ImmBorrowField[22](PoolRewardInfo.last_update_time: u64)
22ReadRef
23Le
24BrFalse(33)
B1:
25MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
26Pop
27MoveLoc[6](loc2: &mut PoolRewardInfo)
28Pop
29MoveLoc[3](Arg3: &TxContext)
30Pop
31LdConst[9](u64: 9)
32Abort
B2:
33CopyLoc[6](loc2: &mut PoolRewardInfo)
34ImmBorrowField[24](PoolRewardInfo.total_reward: u64)
35ReadRef
36ImmBorrowLoc[1](Arg1: Balance<Ty2>)
37Call balance::value<Ty2>(&Balance<Ty2>): u64
38Add
39CopyLoc[6](loc2: &mut PoolRewardInfo)
40MutBorrowField[24](PoolRewardInfo.total_reward: u64)
41WriteRef
42MoveLoc[4](loc0: u64)
43CopyLoc[6](loc2: &mut PoolRewardInfo)
44MutBorrowField[23](PoolRewardInfo.ended_at_seconds: u64)
45WriteRef
46CopyLoc[6](loc2: &mut PoolRewardInfo)
47ImmBorrowField[24](PoolRewardInfo.total_reward: u64)
48ReadRef
49CopyLoc[6](loc2: &mut PoolRewardInfo)
50ImmBorrowField[25](PoolRewardInfo.total_reward_allocated: u64)
51ReadRef
52Sub
53CastU128
54Call constants::get_q64(): u128
55CastU128
56CopyLoc[6](loc2: &mut PoolRewardInfo)
57ImmBorrowField[23](PoolRewardInfo.ended_at_seconds: u64)
58ReadRef
59CopyLoc[6](loc2: &mut PoolRewardInfo)
60ImmBorrowField[22](PoolRewardInfo.last_update_time: u64)
61ReadRef
62Sub
63CastU128
64Call full_math_u128::mul_div_floor(u128, u128, u128): u128
65CopyLoc[6](loc2: &mut PoolRewardInfo)
66MutBorrowField[26](PoolRewardInfo.reward_per_seconds: u128)
67WriteRef
68MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
69MutBorrowFieldGeneric[23](Pool.id: UID)
70LdFalse
71PackGeneric[1](PoolRewardCustodianDfKey<Ty2>)
72Call dynamic_field::borrow_mut<PoolRewardCustodianDfKey<Ty2>, Balance<Ty2>>(&mut UID, PoolRewardCustodianDfKey<Ty2>): &mut Balance<Ty2>
73MoveLoc[1](Arg1: Balance<Ty2>)
74Call balance::join<Ty2>(&mut Balance<Ty2>, Balance<Ty2>): u64
75Pop
76MoveLoc[3](Arg3: &TxContext)
77Call tx_context::sender(&TxContext): address
78MoveLoc[5](loc1: ID)
79CopyLoc[6](loc2: &mut PoolRewardInfo)
80ImmBorrowField[21](PoolRewardInfo.reward_coin_type: TypeName)
81ReadRef
82CopyLoc[6](loc2: &mut PoolRewardInfo)
83ImmBorrowField[24](PoolRewardInfo.total_reward: u64)
84ReadRef
85CopyLoc[6](loc2: &mut PoolRewardInfo)
86ImmBorrowField[23](PoolRewardInfo.ended_at_seconds: u64)
87ReadRef
88MoveLoc[6](loc2: &mut PoolRewardInfo)
89ImmBorrowField[26](PoolRewardInfo.reward_per_seconds: u128)
90ReadRef
91Pack[17](UpdatePoolRewardEmission)
92Call event::emit<UpdatePoolRewardEmission>(UpdatePoolRewardEmission)
93Ret
}
modify_position<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut Position, Arg2: I128, Arg3: &Clock): u64 * u64 {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
L8: loc4: u64
L9: loc5: u64
L10: loc6: bool
L11: loc7: u128
L12: loc8: u64
L13: loc9: I32
L14: loc10: I32
B0:
0CopyLoc[2](Arg2: I128)
1Call i128::is_neg(I128): bool
2Not
3StLoc[10](loc6: bool)
4CopyLoc[1](Arg1: &mut Position)
5FreezeRef
6Call position::tick_lower_index(&Position): I32
7CopyLoc[1](Arg1: &mut Position)
8FreezeRef
9Call position::tick_upper_index(&Position): I32
10StLoc[14](loc10: I32)
11StLoc[13](loc9: I32)
12CopyLoc[2](Arg2: I128)
13Call i128::abs_u128(I128): u128
14StLoc[11](loc7: u128)
15CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
16MoveLoc[1](Arg1: &mut Position)
17CopyLoc[2](Arg2: I128)
18CopyLoc[3](Arg3: &Clock)
19Call update_position<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut Position, I128, &Clock)
20CopyLoc[2](Arg2: I128)
21Call i128::zero(): I128
22Call i128::eq(I128, I128): bool
23Not
24BrFalse(131)
B1:
25CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
26ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
27ReadRef
28CopyLoc[13](loc9: I32)
29Call i32::lt(I32, I32): bool
30BrFalse(46)
B2:
31MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
32Pop
33MoveLoc[3](Arg3: &Clock)
34Pop
35MoveLoc[13](loc9: I32)
36Call tick_math::get_sqrt_price_at_tick(I32): u128
37MoveLoc[14](loc10: I32)
38Call tick_math::get_sqrt_price_at_tick(I32): u128
39MoveLoc[11](loc7: u128)
40MoveLoc[10](loc6: bool)
41Call sqrt_price_math::get_amount_x_delta(u128, u128, u128, bool): u64
42LdU64(0)
43StLoc[7](loc3: u64)
44StLoc[6](loc2: u64)
45Branch(126)
B3:
46CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
47ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
48ReadRef
49CopyLoc[14](loc10: I32)
50Call i32::lt(I32, I32): bool
51BrFalse(108)
B4:
52CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
53MutBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
54CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
55ImmBorrowFieldGeneric[4](Pool.observation_index: u64)
56ReadRef
57MoveLoc[3](Arg3: &Clock)
58Call clock::timestamp_ms(&Clock): u64
59Call utils::to_seconds(u64): u64
60CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
61ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
62ReadRef
63CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
64ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
65ReadRef
66CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
67ImmBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
68ReadRef
69CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
70ImmBorrowFieldGeneric[6](Pool.observation_cardinality_next: u64)
71ReadRef
72Call oracle::write(&mut vector<Observation>, u64, u64, I32, u128, u64, u64): u64 * u64
73StLoc[12](loc8: u64)
74CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
75MutBorrowFieldGeneric[4](Pool.observation_index: u64)
76WriteRef
77MoveLoc[12](loc8: u64)
78CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
79MutBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
80WriteRef
81CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
82ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
83ReadRef
84MoveLoc[2](Arg2: I128)
85Call liquidity_math::add_delta(u128, I128): u128
86CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
87MutBorrowFieldGeneric[15](Pool.liquidity: u128)
88WriteRef
89CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
90ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
91ReadRef
92MoveLoc[14](loc10: I32)
93Call tick_math::get_sqrt_price_at_tick(I32): u128
94CopyLoc[11](loc7: u128)
95CopyLoc[10](loc6: bool)
96Call sqrt_price_math::get_amount_x_delta(u128, u128, u128, bool): u64
97MoveLoc[13](loc9: I32)
98Call tick_math::get_sqrt_price_at_tick(I32): u128
99MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
100ImmBorrowFieldGeneric[2](Pool.sqrt_price: u128)
101ReadRef
102MoveLoc[11](loc7: u128)
103MoveLoc[10](loc6: bool)
104Call sqrt_price_math::get_amount_y_delta(u128, u128, u128, bool): u64
105StLoc[5](loc1: u64)
106StLoc[4](loc0: u64)
107Branch(122)
B5:
108MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
109Pop
110MoveLoc[3](Arg3: &Clock)
111Pop
112LdU64(0)
113MoveLoc[13](loc9: I32)
114Call tick_math::get_sqrt_price_at_tick(I32): u128
115MoveLoc[14](loc10: I32)
116Call tick_math::get_sqrt_price_at_tick(I32): u128
117MoveLoc[11](loc7: u128)
118MoveLoc[10](loc6: bool)
119Call sqrt_price_math::get_amount_y_delta(u128, u128, u128, bool): u64
120StLoc[5](loc1: u64)
121StLoc[4](loc0: u64)
B6:
122MoveLoc[4](loc0: u64)
123MoveLoc[5](loc1: u64)
124StLoc[7](loc3: u64)
125StLoc[6](loc2: u64)
B7:
126MoveLoc[6](loc2: u64)
127MoveLoc[7](loc3: u64)
128StLoc[9](loc5: u64)
129StLoc[8](loc4: u64)
130Branch(139)
B8:
131MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
132Pop
133MoveLoc[3](Arg3: &Clock)
134Pop
135LdU64(0)
136LdU64(0)
137StLoc[9](loc5: u64)
138StLoc[8](loc4: u64)
B9:
139MoveLoc[8](loc4: u64)
140MoveLoc[9](loc5: u64)
141Ret
}
update_position<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut Position, Arg2: I128, Arg3: &Clock) {
L4: loc0: bool
L5: loc1: bool
L6: loc2: u128
L7: loc3: u128
L8: loc4: bool
L9: loc5: bool
L10: loc6: bool
L11: loc7: bool
L12: loc8: vector<u128>
L13: loc9: vector<u128>
L14: loc10: u256
L15: loc11: I64
L16: loc12: I32
L17: loc13: I32
L18: loc14: u64
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1CopyLoc[3](Arg3: &Clock)
2Call clock::timestamp_ms(&Clock): u64
3Call utils::to_seconds(u64): u64
4Call update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>
5StLoc[12](loc8: vector<u128>)
6CopyLoc[1](Arg1: &mut Position)
7FreezeRef
8Call position::tick_lower_index(&Position): I32
9CopyLoc[1](Arg1: &mut Position)
10FreezeRef
11Call position::tick_upper_index(&Position): I32
12StLoc[17](loc13: I32)
13StLoc[16](loc12: I32)
14CopyLoc[2](Arg2: I128)
15Call i128::zero(): I128
16Call i128::eq(I128, I128): bool
17Not
18BrFalse(111)
B1:
19MoveLoc[3](Arg3: &Clock)
20Call clock::timestamp_ms(&Clock): u64
21Call utils::to_seconds(u64): u64
22StLoc[18](loc14: u64)
23CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
24ImmBorrowFieldGeneric[18](Pool.observations: vector<Observation>)
25CopyLoc[18](loc14: u64)
26LdU64(0)
27CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
28ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
29ReadRef
30CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
31ImmBorrowFieldGeneric[4](Pool.observation_index: u64)
32ReadRef
33CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
34ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
35ReadRef
36CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
37ImmBorrowFieldGeneric[5](Pool.observation_cardinality: u64)
38ReadRef
39Call oracle::observe_single(&vector<Observation>, u64, u64, I32, u64, u128, u64): I64 * u256
40StLoc[14](loc10: u256)
41StLoc[15](loc11: I64)
42CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
43MutBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
44CopyLoc[16](loc12: I32)
45CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
46ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
47ReadRef
48CopyLoc[2](Arg2: I128)
49CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
50ImmBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
51ReadRef
52CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
53ImmBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
54ReadRef
55CopyLoc[12](loc8: vector<u128>)
56CopyLoc[14](loc10: u256)
57CopyLoc[15](loc11: I64)
58CopyLoc[18](loc14: u64)
59LdFalse
60CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
61ImmBorrowFieldGeneric[8](Pool.max_liquidity_per_tick: u128)
62ReadRef
63Call tick::update(&mut Table<I32, TickInfo>, I32, I32, I128, u128, u128, vector<u128>, u256, I64, u64, bool, u128): bool
64CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
65MutBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
66CopyLoc[17](loc13: I32)
67CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
68ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
69ReadRef
70CopyLoc[2](Arg2: I128)
71CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
72ImmBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
73ReadRef
74CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
75ImmBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
76ReadRef
77CopyLoc[12](loc8: vector<u128>)
78MoveLoc[14](loc10: u256)
79MoveLoc[15](loc11: I64)
80MoveLoc[18](loc14: u64)
81LdTrue
82CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
83ImmBorrowFieldGeneric[8](Pool.max_liquidity_per_tick: u128)
84ReadRef
85Call tick::update(&mut Table<I32, TickInfo>, I32, I32, I128, u128, u128, vector<u128>, u256, I64, u64, bool, u128): bool
86StLoc[11](loc7: bool)
87StLoc[9](loc5: bool)
88CopyLoc[9](loc5: bool)
89BrFalse(97)
B2:
90CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
91MutBorrowFieldGeneric[17](Pool.tick_bitmap: Table<I32, u256>)
92CopyLoc[16](loc12: I32)
93CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
94ImmBorrowFieldGeneric[7](Pool.tick_spacing: u32)
95ReadRef
96Call tick_bitmap::flip_tick(&mut Table<I32, u256>, I32, u32)
B3:
97CopyLoc[11](loc7: bool)
98BrFalse(106)
B4:
99CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
100MutBorrowFieldGeneric[17](Pool.tick_bitmap: Table<I32, u256>)
101CopyLoc[17](loc13: I32)
102CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
103ImmBorrowFieldGeneric[7](Pool.tick_spacing: u32)
104ReadRef
105Call tick_bitmap::flip_tick(&mut Table<I32, u256>, I32, u32)
B5:
106MoveLoc[9](loc5: bool)
107MoveLoc[11](loc7: bool)
108StLoc[5](loc1: bool)
109StLoc[4](loc0: bool)
110Branch(117)
B6:
111MoveLoc[3](Arg3: &Clock)
112Pop
113LdFalse
114LdFalse
115StLoc[5](loc1: bool)
116StLoc[4](loc0: bool)
B7:
117MoveLoc[4](loc0: bool)
118MoveLoc[5](loc1: bool)
119StLoc[10](loc6: bool)
120StLoc[8](loc4: bool)
121CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
122ImmBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
123CopyLoc[16](loc12: I32)
124CopyLoc[17](loc13: I32)
125CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
126ImmBorrowFieldGeneric[3](Pool.tick_index: I32)
127ReadRef
128CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
129ImmBorrowFieldGeneric[11](Pool.fee_growth_global_x: u128)
130ReadRef
131CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
132ImmBorrowFieldGeneric[12](Pool.fee_growth_global_y: u128)
133ReadRef
134MoveLoc[12](loc8: vector<u128>)
135Call tick::get_fee_and_reward_growths_inside(&Table<I32, TickInfo>, I32, I32, I32, u128, u128, vector<u128>): u128 * u128 * vector<u128>
136StLoc[13](loc9: vector<u128>)
137StLoc[7](loc3: u128)
138StLoc[6](loc2: u128)
139MoveLoc[1](Arg1: &mut Position)
140CopyLoc[2](Arg2: I128)
141MoveLoc[6](loc2: u128)
142MoveLoc[7](loc3: u128)
143MoveLoc[13](loc9: vector<u128>)
144Call position::update(&mut Position, I128, u128, u128, vector<u128>)
145MoveLoc[2](Arg2: I128)
146Call i128::zero(): I128
147Call i128::lt(I128, I128): bool
148BrFalse(165)
B8:
149MoveLoc[8](loc4: bool)
150BrFalse(155)
B9:
151CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
152MutBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
153MoveLoc[16](loc12: I32)
154Call tick::clear(&mut Table<I32, TickInfo>, I32)
B10:
155MoveLoc[10](loc6: bool)
156BrFalse(162)
B11:
157MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
158MutBorrowFieldGeneric[16](Pool.ticks: Table<I32, TickInfo>)
159MoveLoc[17](loc13: I32)
160Call tick::clear(&mut Table<I32, TickInfo>, I32)
161Branch(164)
B12:
162MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
163Pop
B13:
164Branch(167)
B14:
165MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
166Pop
B15:
167Ret
}
update_reward_infos<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64): vector<u128> {
L2: loc0: bool
L3: loc1: u64
L4: loc2: u64
L5: loc3: u64
L6: loc4: u256
L7: loc5: u256
L8: loc6: vector<u128>
L9: loc7: &mut PoolRewardInfo
B0:
0VecPack(3, 0)
1StLoc[8](loc6: vector<u128>)
2LdU64(0)
3CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
4ImmBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
5VecLen(51)
6StLoc[5](loc3: u64)
7StLoc[3](loc1: u64)
B1:
8CopyLoc[3](loc1: u64)
9CopyLoc[5](loc3: u64)
10Lt
11BrFalse(100)
B2:
12Branch(13)
B3:
13CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
14MutBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
15CopyLoc[3](loc1: u64)
16VecMutBorrow(51)
17StLoc[9](loc7: &mut PoolRewardInfo)
18MoveLoc[3](loc1: u64)
19LdU64(1)
20Add
21StLoc[3](loc1: u64)
22CopyLoc[1](Arg1: u64)
23CopyLoc[9](loc7: &mut PoolRewardInfo)
24ImmBorrowField[22](PoolRewardInfo.last_update_time: u64)
25ReadRef
26Gt
27BrFalse(94)
B4:
28CopyLoc[1](Arg1: u64)
29CopyLoc[9](loc7: &mut PoolRewardInfo)
30ImmBorrowField[23](PoolRewardInfo.ended_at_seconds: u64)
31ReadRef
32Call math::min(u64, u64): u64
33StLoc[4](loc2: u64)
34CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
35ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
36ReadRef
37LdU128(0)
38Neq
39BrFalse(47)
B5:
40CopyLoc[4](loc2: u64)
41CopyLoc[9](loc7: &mut PoolRewardInfo)
42ImmBorrowField[22](PoolRewardInfo.last_update_time: u64)
43ReadRef
44Gt
45StLoc[2](loc0: bool)
46Branch(49)
B6:
47LdFalse
48StLoc[2](loc0: bool)
B7:
49MoveLoc[2](loc0: bool)
50BrFalse(90)
B8:
51MoveLoc[4](loc2: u64)
52CopyLoc[9](loc7: &mut PoolRewardInfo)
53ImmBorrowField[22](PoolRewardInfo.last_update_time: u64)
54ReadRef
55Sub
56CastU128
57CopyLoc[9](loc7: &mut PoolRewardInfo)
58ImmBorrowField[26](PoolRewardInfo.reward_per_seconds: u128)
59ReadRef
60Call full_math_u128::full_mul(u128, u128): u256
61StLoc[6](loc4: u256)
62CopyLoc[6](loc4: u256)
63CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
64ImmBorrowFieldGeneric[15](Pool.liquidity: u128)
65ReadRef
66CastU256
67Div
68StLoc[7](loc5: u256)
69CopyLoc[9](loc7: &mut PoolRewardInfo)
70ImmBorrowField[27](PoolRewardInfo.reward_growth_global: u128)
71ReadRef
72MoveLoc[7](loc5: u256)
73CastU128
74Call full_math_u128::wrapping_add(u128, u128): u128
75CopyLoc[9](loc7: &mut PoolRewardInfo)
76MutBorrowField[27](PoolRewardInfo.reward_growth_global: u128)
77WriteRef
78CopyLoc[9](loc7: &mut PoolRewardInfo)
79ImmBorrowField[25](PoolRewardInfo.total_reward_allocated: u64)
80ReadRef
81MoveLoc[6](loc4: u256)
82Call constants::get_q64(): u128
83CastU256
84Div
85CastU64
86Add
87CopyLoc[9](loc7: &mut PoolRewardInfo)
88MutBorrowField[25](PoolRewardInfo.total_reward_allocated: u64)
89WriteRef
B9:
90CopyLoc[1](Arg1: u64)
91CopyLoc[9](loc7: &mut PoolRewardInfo)
92MutBorrowField[22](PoolRewardInfo.last_update_time: u64)
93WriteRef
B10:
94MutBorrowLoc[8](loc6: vector<u128>)
95MoveLoc[9](loc7: &mut PoolRewardInfo)
96ImmBorrowField[27](PoolRewardInfo.reward_growth_global: u128)
97ReadRef
98VecPushBack(3)
99Branch(8)
B11:
100MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
101Pop
102MoveLoc[8](loc6: vector<u128>)
103Ret
}
find_reward_info_index<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1>): u64 {
L1: loc0: u64
L2: loc1: bool
L3: loc2: u64
L4: loc3: u64
B0:
0LdU64(0)
1CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
2ImmBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
3VecLen(51)
4StLoc[4](loc3: u64)
5StLoc[3](loc2: u64)
6LdFalse
7CopyLoc[3](loc2: u64)
8StLoc[1](loc0: u64)
9StLoc[2](loc1: bool)
B1:
10CopyLoc[3](loc2: u64)
11CopyLoc[4](loc3: u64)
12Lt
13BrFalse(36)
B2:
14Branch(15)
B3:
15CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
16ImmBorrowFieldGeneric[20](Pool.reward_infos: vector<PoolRewardInfo>)
17CopyLoc[3](loc2: u64)
18VecImmBorrow(51)
19ImmBorrowField[21](PoolRewardInfo.reward_coin_type: TypeName)
20ReadRef
21Call type_name::get<Ty2>(): TypeName
22Eq
23BrFalse(31)
B4:
24MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
25Pop
26LdTrue
27MoveLoc[3](loc2: u64)
28StLoc[1](loc0: u64)
29StLoc[2](loc1: bool)
30Branch(36)
B5:
31MoveLoc[3](loc2: u64)
32LdU64(1)
33Add
34StLoc[3](loc2: u64)
35Branch(10)
B6:
36MoveLoc[2](loc1: bool)
37Not
38BrFalse(41)
B7:
39LdConst[10](u64: 10)
40Abort
B8:
41MoveLoc[1](loc0: u64)
42Ret
}
check_pool_match<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID) {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
2MoveLoc[1](Arg1: ID)
3Neq
4BrFalse(7)
B1:
5LdConst[0](u64: 0)
6Abort
B2:
7Ret
}
check_lock<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
1ImmBorrowFieldGeneric[19](Pool.locked: bool)
2ReadRef
3BrFalse(6)
B1:
4LdConst[3](u64: 3)
5Abort
B2:
6Ret
}
take<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64): Balance<Ty0> * Balance<Ty1> {
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1MutBorrowFieldGeneric[21](Pool.reserve_x: Balance<Ty0>)
2MoveLoc[1](Arg1: u64)
3Call safe_withdraw<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
4MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
5MutBorrowFieldGeneric[22](Pool.reserve_y: Balance<Ty1>)
6MoveLoc[2](Arg2: u64)
7Call safe_withdraw<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
8Ret
}
put<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Balance<Ty0>, Arg2: Balance<Ty1>) {
B0:
0CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1MutBorrowFieldGeneric[21](Pool.reserve_x: Balance<Ty0>)
2MoveLoc[1](Arg1: Balance<Ty0>)
3Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
4Pop
5MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
6MutBorrowFieldGeneric[22](Pool.reserve_y: Balance<Ty1>)
7MoveLoc[2](Arg2: Balance<Ty1>)
8Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
9Pop
10Ret
}
safe_withdraw<Ty0>(Arg0: &mut Balance<Ty0>, Arg1: u64): Balance<Ty0> {
L2: loc0: u64
B0:
0MoveLoc[1](Arg1: u64)
1CopyLoc[0](Arg0: &mut Balance<Ty0>)
2FreezeRef
3Call balance::value<Ty0>(&Balance<Ty0>): u64
4Call math::min(u64, u64): u64
5StLoc[2](loc0: u64)
6MoveLoc[0](Arg0: &mut Balance<Ty0>)
7MoveLoc[2](loc0: u64)
8Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
9Ret
}
Constants [
0 => u64: 0
1 => u64: 1
2 => u64: 2
3 => u64: 3
4 => u64: 4
5 => u64: 5
6 => u64: 6
7 => u64: 7
8 => u64: 8
9 => u64: 9
10 => u64: 10
11 => u64: 11
]
}