tide
SUI$0.82230.52%USDC$1.00DEEP$0.01390.01%WAL$0.02751.83%CETUS$0.01920.75%NAVX$0.008155.01%IKA$0.00095930.58%HAEDAL$0.02625.97%MMT$0.11872.07%BLUE$0.007011.82%NS$0.008800.27%USDT$0.9987haSUI$0.89291.34%

Search by name, SuiNS, address, digest, object ID, coin type or checkpoint.

API

pool

Module0xf6a6…4b1b
Move path
0xc872…04c5::pool
Functions
10581 public, 3 entry
Structs
54
Friend modules
None
pool

Bytecode5466 lines

The on-chain disassembly. Offsets are bytecode positions within each function.

// Move bytecode v7
module c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5.pool {
use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::admin;
use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::constants;
use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::helper;
use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::internal_price;
use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::math;
use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::price_oracle;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000001::u128;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
 
struct LPPosition<phantom Ty0> has store, key {
id: UID,
pool_id: ID,
shares: u64,
paid_rps: Table<String, u128>,
claimable_rewards: Table<String, u64>
}
 
struct ProtocolFeeClaimCap has store, key {
id: UID
}
 
struct GlobalConfig has key {
id: UID,
config_cap: GlobalConfigCap,
max_quote_assets_per_pool: u64,
max_swap_fee_pct: u64,
max_lp_withdrawal_fee_pct: u64,
max_lp_fee_share: u64,
max_dynamic_fee: u64,
is_protocol_paused: bool,
total_pools_created: u64,
version: u64,
bag: Bag
}
 
struct LiquidityPool<phantom Ty0> has store, key {
id: UID,
base_reserve: Balance<Ty0>,
min_base_out: u64,
total_lp_shares: u64,
swap_fee_pct: u64,
lp_withdrawal_fee_pct: u64,
lp_fee_pct: u64,
max_dynamic_fee: u64,
limit_ratio: u64,
admin: address,
is_permissioned: bool,
whitelisted_lps: vector<address>,
is_paused: bool,
supported_assets: vector<String>,
reward_rps: Table<String, u128>,
protocol_base_fees: Balance<Ty0>,
version: u64,
bag: Bag
}
 
struct QuoteAssetReserve<phantom Ty0> has store {
balance: Balance<Ty0>,
collected_rewards: Balance<Ty0>,
ideal_reserve_pct: u64,
max_reserve_pct: u64,
ideal_reserve_calc: u128,
fee_base: u64,
fee_max: u64,
min_out: u64,
limit_ratio: Option<u64>,
limit_fixed: Option<u64>,
is_trading: bool
}
 
struct FlashSwapPromise<phantom Ty0, phantom Ty1> {
pool_id: ID,
borrowed_amount: u64,
repayment_amount: u64,
price: u128
}
 
struct MarketPausedEvent<phantom Ty0> has copy, drop {
pool_id: ID,
reason: String
}
 
struct MarketUnpausedEvent<phantom Ty0> has copy, drop {
pool_id: ID
}
 
struct FlashSwapEnabledSet<phantom Ty0> has copy, drop {
pool_id: ID,
enabled: bool
}
 
struct FlashBorrowEvent<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
borrower: address,
borrowed_amount: u64,
repayment_amount: u64,
price: u128
}
 
struct FlashRepayEvent<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
borrower: address,
repaid: u64,
fee: u64,
surplus: u64
}
 
struct FlashSwapProtocolFeeSet<phantom Ty0> has copy, drop {
pool_id: ID,
fee: u64
}
 
struct GlobalConfigCreated has copy, drop {
global_config_id: ID
}
 
struct GlobalConfigUpdated has copy, drop {
global_config_id: ID,
updated_by: address
}
 
struct ProtocolPausedUpdated has copy, drop {
global_config_id: ID,
is_paused: bool,
updated_by: address
}
 
struct PoolCreated has copy, drop {
pool_id: ID,
base_asset: TypeName,
admin: address,
created_via_global_config: bool
}
 
struct PoolConfigUpdated has copy, drop {
pool_id: ID,
new_swap_fee_pct: Option<u64>,
new_lp_withdrawal_fee_pct: Option<u64>,
new_lp_fee: Option<u64>,
new_max_dynamic_fee_bps: Option<u64>,
new_limit_ratio_bps: Option<u64>,
updated_by: address
}
 
struct QuoteAssetAdded<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
quote_asset: String,
ideal_reserve_pct: u64,
max_reserve_pct: u64,
fee_base: u64,
fee_max: u64,
limit_ratio_bps: Option<u64>,
limit_fixed: Option<u64>,
min_out: u64,
added_by: address
}
 
struct QuoteAssetUpdated<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
quote_asset: String,
ideal_reserve_pct: Option<u64>,
max_reserve_pct: Option<u64>,
fee_base: Option<u64>,
fee_max: Option<u64>,
limit_ratio_bps: Option<u64>,
limit_fixed: Option<u64>,
min_out: Option<u64>,
is_trading: Option<bool>,
updated_by: address
}
 
struct LPWhitelisted<phantom Ty0> has copy, drop {
pool_id: ID,
lp_addresses: vector<address>
}
 
struct LpRemovedFromWhitelist<phantom Ty0> has copy, drop {
pool_id: ID,
lp_addresses: vector<address>
}
 
struct PoolPermissionUpdated<phantom Ty0> has copy, drop {
pool_id: ID,
is_permissioned: bool
}
 
struct LiquidityAdded<phantom Ty0> has copy, drop {
pool_id: ID,
provider: address,
base_amount: u64,
lp_shares_minted: u64,
total_lp_shares: u64,
is_new_lp: bool
}
 
struct LiquidityRemoved<phantom Ty0> has copy, drop {
pool_id: ID,
provider: address,
base_amount: u64,
lp_shares_burned: u64,
total_lp_shares: u64
}
 
struct BaseWithdrawn<phantom Ty0> has copy, drop {
pool_id: ID,
admin: address,
base_amount: u64
}
 
struct QuoteWithdrawn<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
admin: address,
quote_asset: String,
quote_amount: u64,
rewards_amount: u64
}
 
struct RewardsClaimed<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
provider: address,
reward_asset: String,
claimed_amount: u64
}
 
struct ProtocolFeesWithdrawn<phantom Ty0> has copy, drop {
pool_id: ID,
recipient: address,
amount: u64
}
 
struct SwapExecuted<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
trader: address,
amount_in: u64,
amount_out: u64,
is_buy: bool,
dynamic_fee_pct: u64,
ideal_quote_amt: u128,
total_fee_pct: u64,
swap_fee: u64,
lp_fee: u64,
protocol_fee: u64,
price_used: u128
}
 
struct SwapExecutedV2<phantom Ty0, phantom Ty1> has copy, drop {
pool_id: ID,
trader: address,
amount_in: u64,
amount_out: u64,
is_buy: bool,
dynamic_fee_pct: u64,
ideal_quote_amt: u128,
total_fee_pct: u64,
swap_fee: u64,
lp_fee: u64,
protocol_fee: u64,
price_used: u128,
base_liquidity: u64,
quote_reserve_amount: u64
}
 
struct PriceUpdated has copy, drop {
dummy_field: bool
}
 
struct AdminUpdated<phantom Ty0> has copy, drop {
pool_id: ID,
old_admin: address,
new_admin: address
}
 
struct NetBaseFeeMultiplierKey has copy, drop, store {
dummy_field: bool
}
 
struct NetBaseFeeMultiplierKeyUpdated has copy, drop {
pool_id: ID,
new_net_base_fee_multiplier: u64
}
 
struct IdealBaseAnchorKey has copy, drop, store {
dummy_field: bool
}
 
struct IdealBaseAnchorUpdated has copy, drop {
pool_id: ID,
new_anchor: u64
}
 
struct FlashSwapEnabledKey has copy, drop, store {
dummy_field: bool
}
 
struct FlashSwapProtocolFeeKey has copy, drop, store {
dummy_field: bool
}
 
struct ClaimableRewardsInfo has copy, drop {
asset: String,
amount: u64,
reward_rps: u128,
paid_rps: u128
}
 
struct WithdrawSharesSimulationResult has copy, drop {
shares_burn: u64,
base_out_gross: u64,
base_fee: u64,
total_base_fees: u64,
base_out: u64,
total_lp_shares: u64,
net_base_added: u64
}
 
struct SwapSimulationResult has copy, drop {
base_out: u64,
quote_out: u64,
swap_fee_pct: u64,
dynamic_fee_pct: u64,
ideal_quote_amt: u128,
swap_fee: u64,
lp_fee: u64,
protocol_fee: u64,
price_used: u128
}
 
struct GlobalConfigInfo has copy, drop {
total_pools_created: u64,
max_quote_assets_per_pool: u64
}
 
struct GlobalFeeInfo has copy, drop {
max_swap_fee_pct: u64,
max_lp_withdrawal_fee_pct: u64,
max_lp_fee_share: u64,
max_dynamic_fee: u64
}
 
struct PoolDetailedInfo<phantom Ty0> has drop {
base_asset: String,
info: PoolInfo,
config: PoolConfig,
supported_quotes: vector<String>,
reward_rps: vector<RewardRPSEntry>,
is_paused: bool,
admin: address,
limit_ratio: u64,
is_permissioned: bool
}
 
struct RewardRPSEntry has copy, drop {
asset: String,
rps: u128
}
 
struct PaidRPSEntry has copy, drop {
asset: String,
rps: u128
}
 
struct PoolInfo has copy, drop {
id: ID,
base_liquidity: u64,
net_base_added: u64,
total_lp_shares: u64,
protocol_base_fees: u64,
admin: address,
is_paused: bool
}
 
struct PoolConfig has copy, drop {
swap_fee_pct: u64,
lp_withdrawal_fee_pct: u64,
lp_fee_pct: u64,
max_dynamic_fee: u64,
limit_ratio: u64,
min_base_out: u64
}
 
struct SupportedAssetsInfo has copy, drop {
base_asset: String,
supported_quotes: vector<String>
}
 
struct WithdrawableBaseByLp has copy, drop {
withdrawable_base: u64,
withdraw_fee: u64,
shares_to_burn: u64
}
 
struct BaseLiquidityInfo<phantom Ty0> has drop {
base_reserve: u64,
total_lp_shares: u64
}
 
struct LPPositionInfo has copy, drop {
pool_id: ID,
shares: u64,
claimable_rewards: vector<ClaimableRewardsInfo>,
paid_rps: vector<PaidRPSEntry>
}
 
struct ProtocolFeesInfo has copy, drop {
swap_fee_pct: u64,
lp_withdrawal_fee_pct: u64
}
 
struct QuoteAssetInfo has copy, drop {
asset: String,
balance: u64,
ideal_reserve_pct: u64,
max_reserve_pct: u64,
fee_base: u64,
fee_max: u64,
limit_ratio: Option<u64>,
limit_fixed: Option<u64>,
min_out: u64,
is_trading: bool
}
 
public get_precision(): u128 {
B0:
0LdConst[31](u128: 1000..)
1Ret
}
 
public get_basis_points(): u64 {
B0:
0LdConst[32](u64: 10000)
1Ret
}
 
public get_initial_lp_multiplier(): u64 {
B0:
0LdConst[34](u64: 1000)
1Ret
}
 
public get_max_lp_fee_share(): u64 {
B0:
0LdConst[35](u64: 9000)
1Ret
}
 
entry migrate_module_version(Arg0: &ProtocolAdminCap, Arg1: &mut GlobalConfig) {
B0:
0CopyLoc[1](Arg1: &mut GlobalConfig)
1ImmBorrowField[0](GlobalConfig.version: u64)
2ReadRef
3Call constants::get_version(): u64
4Lt
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[1](Arg1: &mut GlobalConfig)
8Pop
9LdConst[9](u64: 4011)
10Abort
B3:
11Call constants::get_version(): u64
12MoveLoc[1](Arg1: &mut GlobalConfig)
13MutBorrowField[0](GlobalConfig.version: u64)
14WriteRef
15Ret
}
 
entry migrate_pool_version<Ty0>(Arg0: &ProtocolAdminCap, Arg1: &mut LiquidityPool<Ty0>) {
L2: loc0: u64
B0:
0CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[0](LiquidityPool.version: u64)
2ReadRef
3Call constants::get_version(): u64
4Lt
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
8Pop
9LdConst[9](u64: 4011)
10Abort
B3:
11Call constants::get_version(): u64
12CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
13MutBorrowFieldGeneric[0](LiquidityPool.version: u64)
14WriteRef
15CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
16ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
17LdFalse
18Pack[36](FlashSwapEnabledKey)
19Call dynamic_field::exists_<FlashSwapEnabledKey>(&UID, FlashSwapEnabledKey): bool
20Not
21BrFalse(28)
B4:
22CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
23MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
24LdFalse
25Pack[36](FlashSwapEnabledKey)
26LdFalse
27Call dynamic_field::add<FlashSwapEnabledKey, bool>(&mut UID, FlashSwapEnabledKey, bool)
B5:
28CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
29ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
30LdFalse
31Pack[37](FlashSwapProtocolFeeKey)
32Call dynamic_field::exists_<FlashSwapProtocolFeeKey>(&UID, FlashSwapProtocolFeeKey): bool
33Not
34BrFalse(46)
B6:
35CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
36FreezeRef
37Call default_flash_swap_protocol_fee<Ty0>(&LiquidityPool<Ty0>): u64
38StLoc[2](loc0: u64)
39MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
40MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
41LdFalse
42Pack[37](FlashSwapProtocolFeeKey)
43MoveLoc[2](loc0: u64)
44Call dynamic_field::add<FlashSwapProtocolFeeKey, u64>(&mut UID, FlashSwapProtocolFeeKey, u64)
45Branch(48)
B7:
46MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
47Pop
B8:
48Ret
}
 
init(Arg0: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Pack[1](ProtocolFeeClaimCap)
3MoveLoc[0](Arg0: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Call transfer::public_transfer<ProtocolFeeClaimCap>(ProtocolFeeClaimCap, address)
7Ret
}
 
public initialize_global_config(Arg0: &ProtocolAdminCap, Arg1: GlobalConfigCap, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: &mut TxContext) {
L8: loc0: GlobalConfig
L9: loc1: UID
L10: loc2: ID
B0:
0CopyLoc[7](Arg7: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[9](loc1: UID)
3ImmBorrowLoc[9](loc1: UID)
4Call object::uid_to_inner(&UID): ID
5StLoc[10](loc2: ID)
6MoveLoc[9](loc1: UID)
7MoveLoc[1](Arg1: GlobalConfigCap)
8MoveLoc[2](Arg2: u64)
9MoveLoc[3](Arg3: u64)
10MoveLoc[4](Arg4: u64)
11MoveLoc[5](Arg5: u64)
12MoveLoc[6](Arg6: u64)
13LdFalse
14LdU64(0)
15Call constants::get_version(): u64
16MoveLoc[7](Arg7: &mut TxContext)
17Call bag::new(&mut TxContext): Bag
18Pack[2](GlobalConfig)
19StLoc[8](loc0: GlobalConfig)
20ImmBorrowLoc[8](loc0: GlobalConfig)
21Call option::none<u64>(): Option<u64>
22Call option::none<u64>(): Option<u64>
23Call option::none<u64>(): Option<u64>
24Call option::none<u64>(): Option<u64>
25Call assert_global_config(&GlobalConfig, Option<u64>, Option<u64>, Option<u64>, Option<u64>)
26MoveLoc[10](loc2: ID)
27Pack[12](GlobalConfigCreated)
28Call event::emit<GlobalConfigCreated>(GlobalConfigCreated)
29MoveLoc[8](loc0: GlobalConfig)
30Call transfer::share_object<GlobalConfig>(GlobalConfig)
31Ret
}
 
public update_global_config(Arg0: &mut GlobalConfig, Arg1: &ProtocolAdminCap, Arg2: Option<u64>, Arg3: Option<u64>, Arg4: Option<u64>, Arg5: Option<u64>, Arg6: Option<u64>, Arg7: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut GlobalConfig)
1FreezeRef
2Call validate_global_config_version(&GlobalConfig)
3CopyLoc[0](Arg0: &mut GlobalConfig)
4FreezeRef
5CopyLoc[3](Arg3: Option<u64>)
6CopyLoc[4](Arg4: Option<u64>)
7CopyLoc[5](Arg5: Option<u64>)
8CopyLoc[6](Arg6: Option<u64>)
9Call assert_global_config(&GlobalConfig, Option<u64>, Option<u64>, Option<u64>, Option<u64>)
10ImmBorrowLoc[2](Arg2: Option<u64>)
11Call option::is_some<u64>(&Option<u64>): bool
12BrFalse(19)
B1:
13ImmBorrowLoc[2](Arg2: Option<u64>)
14Call option::borrow<u64>(&Option<u64>): &u64
15ReadRef
16CopyLoc[0](Arg0: &mut GlobalConfig)
17MutBorrowField[3](GlobalConfig.max_quote_assets_per_pool: u64)
18WriteRef
B2:
19ImmBorrowLoc[3](Arg3: Option<u64>)
20Call option::is_some<u64>(&Option<u64>): bool
21BrFalse(28)
B3:
22ImmBorrowLoc[3](Arg3: Option<u64>)
23Call option::borrow<u64>(&Option<u64>): &u64
24ReadRef
25CopyLoc[0](Arg0: &mut GlobalConfig)
26MutBorrowField[4](GlobalConfig.max_swap_fee_pct: u64)
27WriteRef
B4:
28ImmBorrowLoc[4](Arg4: Option<u64>)
29Call option::is_some<u64>(&Option<u64>): bool
30BrFalse(37)
B5:
31ImmBorrowLoc[4](Arg4: Option<u64>)
32Call option::borrow<u64>(&Option<u64>): &u64
33ReadRef
34CopyLoc[0](Arg0: &mut GlobalConfig)
35MutBorrowField[5](GlobalConfig.max_lp_withdrawal_fee_pct: u64)
36WriteRef
B6:
37ImmBorrowLoc[5](Arg5: Option<u64>)
38Call option::is_some<u64>(&Option<u64>): bool
39BrFalse(46)
B7:
40ImmBorrowLoc[5](Arg5: Option<u64>)
41Call option::borrow<u64>(&Option<u64>): &u64
42ReadRef
43CopyLoc[0](Arg0: &mut GlobalConfig)
44MutBorrowField[6](GlobalConfig.max_lp_fee_share: u64)
45WriteRef
B8:
46ImmBorrowLoc[6](Arg6: Option<u64>)
47Call option::is_some<u64>(&Option<u64>): bool
48BrFalse(55)
B9:
49ImmBorrowLoc[6](Arg6: Option<u64>)
50Call option::borrow<u64>(&Option<u64>): &u64
51ReadRef
52CopyLoc[0](Arg0: &mut GlobalConfig)
53MutBorrowField[7](GlobalConfig.max_dynamic_fee: u64)
54WriteRef
B10:
55MoveLoc[0](Arg0: &mut GlobalConfig)
56ImmBorrowField[8](GlobalConfig.id: UID)
57Call object::uid_to_inner(&UID): ID
58MoveLoc[7](Arg7: &mut TxContext)
59FreezeRef
60Call tx_context::sender(&TxContext): address
61Pack[13](GlobalConfigUpdated)
62Call event::emit<GlobalConfigUpdated>(GlobalConfigUpdated)
63Ret
}
 
public set_protocol_pause(Arg0: &mut GlobalConfig, Arg1: &ProtocolAdminCap, Arg2: bool, Arg3: &mut TxContext) {
B0:
0LdConst[19](u64: 4022)
1Abort
}
 
public withdraw_protocol_fees<Ty0>(Arg0: &ProtocolFeeClaimCap, Arg1: &mut LiquidityPool<Ty0>, Arg2: &mut TxContext) {
L3: loc0: u64
L4: loc1: Balance<Ty0>
L5: loc2: address
B0:
0CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
4MutBorrowFieldGeneric[2](LiquidityPool.protocol_base_fees: Balance<Ty0>)
5Call balance::withdraw_all<Ty0>(&mut Balance<Ty0>): Balance<Ty0>
6StLoc[4](loc1: Balance<Ty0>)
7ImmBorrowLoc[4](loc1: Balance<Ty0>)
8Call balance::value<Ty0>(&Balance<Ty0>): u64
9StLoc[3](loc0: u64)
10CopyLoc[2](Arg2: &mut TxContext)
11FreezeRef
12Call tx_context::sender(&TxContext): address
13StLoc[5](loc2: address)
14MoveLoc[4](loc1: Balance<Ty0>)
15MoveLoc[2](Arg2: &mut TxContext)
16Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
17CopyLoc[5](loc2: address)
18Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
19MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
20ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
21Call object::uid_to_inner(&UID): ID
22MoveLoc[5](loc2: address)
23MoveLoc[3](loc0: u64)
24PackGeneric[0](ProtocolFeesWithdrawn<Ty0>)
25Call event::emit<ProtocolFeesWithdrawn<Ty0>>(ProtocolFeesWithdrawn<Ty0>)
26Ret
}
 
public create_pool<Ty0>(Arg0: &ProtocolAdminCap, Arg1: &mut GlobalConfig, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: bool, Arg8: u64, Arg9: &mut TxContext): ID {
L10: loc0: UID
L11: loc1: address
L12: loc2: bool
L13: loc3: vector<address>
L14: loc4: vector<String>
L15: loc5: Balance<Ty0>
L16: loc6: Table<String, u128>
L17: loc7: u64
L18: loc8: Bag
L19: loc9: Balance<Ty0>
L20: loc10: u64
L21: loc11: u64
L22: loc12: u64
L23: loc13: u64
L24: loc14: u64
L25: loc15: u64
L26: loc16: String
L27: loc17: u64
L28: loc18: LiquidityPool<Ty0>
L29: loc19: ID
L30: loc20: address
B0:
0CopyLoc[1](Arg1: &mut GlobalConfig)
1FreezeRef
2Call validate_global_config_version(&GlobalConfig)
3CopyLoc[9](Arg9: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6StLoc[30](loc20: address)
7Call type_name::with_defining_ids<Ty0>(): TypeName
8Call type_name::into_string(TypeName): String
9StLoc[26](loc16: String)
10CopyLoc[1](Arg1: &mut GlobalConfig)
11FreezeRef
12CopyLoc[2](Arg2: u64)
13Call option::some<u64>(u64): Option<u64>
14CopyLoc[3](Arg3: u64)
15Call option::some<u64>(u64): Option<u64>
16CopyLoc[4](Arg4: u64)
17Call option::some<u64>(u64): Option<u64>
18CopyLoc[5](Arg5: u64)
19Call option::some<u64>(u64): Option<u64>
20CopyLoc[6](Arg6: u64)
21Call option::some<u64>(u64): Option<u64>
22Call assert_pool_fees(&GlobalConfig, Option<u64>, Option<u64>, Option<u64>, Option<u64>, Option<u64>)
23CopyLoc[9](Arg9: &mut TxContext)
24Call object::new(&mut TxContext): UID
25StLoc[10](loc0: UID)
26Call balance::zero<Ty0>(): Balance<Ty0>
27StLoc[19](loc9: Balance<Ty0>)
28MoveLoc[8](Arg8: u64)
29StLoc[20](loc10: u64)
30MoveLoc[2](Arg2: u64)
31StLoc[21](loc11: u64)
32MoveLoc[3](Arg3: u64)
33StLoc[22](loc12: u64)
34MoveLoc[4](Arg4: u64)
35StLoc[23](loc13: u64)
36MoveLoc[5](Arg5: u64)
37StLoc[24](loc14: u64)
38MoveLoc[6](Arg6: u64)
39StLoc[25](loc15: u64)
40CopyLoc[30](loc20: address)
41StLoc[11](loc1: address)
42MoveLoc[7](Arg7: bool)
43StLoc[12](loc2: bool)
44VecPack(81, 0)
45StLoc[13](loc3: vector<address>)
46VecPack(128, 0)
47StLoc[14](loc4: vector<String>)
48Call balance::zero<Ty0>(): Balance<Ty0>
49StLoc[15](loc5: Balance<Ty0>)
50CopyLoc[9](Arg9: &mut TxContext)
51Call table::new<String, u128>(&mut TxContext): Table<String, u128>
52StLoc[16](loc6: Table<String, u128>)
53Call constants::get_version(): u64
54StLoc[17](loc7: u64)
55MoveLoc[9](Arg9: &mut TxContext)
56Call bag::new(&mut TxContext): Bag
57StLoc[18](loc8: Bag)
58MoveLoc[10](loc0: UID)
59MoveLoc[19](loc9: Balance<Ty0>)
60MoveLoc[20](loc10: u64)
61LdU64(0)
62MoveLoc[21](loc11: u64)
63MoveLoc[22](loc12: u64)
64MoveLoc[23](loc13: u64)
65MoveLoc[24](loc14: u64)
66MoveLoc[25](loc15: u64)
67MoveLoc[11](loc1: address)
68MoveLoc[12](loc2: bool)
69MoveLoc[13](loc3: vector<address>)
70LdFalse
71MoveLoc[14](loc4: vector<String>)
72MoveLoc[16](loc6: Table<String, u128>)
73MoveLoc[15](loc5: Balance<Ty0>)
74MoveLoc[17](loc7: u64)
75MoveLoc[18](loc8: Bag)
76PackGeneric[1](LiquidityPool<Ty0>)
77StLoc[28](loc18: LiquidityPool<Ty0>)
78MutBorrowLoc[28](loc18: LiquidityPool<Ty0>)
79MutBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
80CopyLoc[26](loc16: String)
81LdU128(0)
82Call table::add<String, u128>(&mut Table<String, u128>, String, u128)
83MutBorrowLoc[28](loc18: LiquidityPool<Ty0>)
84MutBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
85MoveLoc[26](loc16: String)
86VecPushBack(128)
87CopyLoc[1](Arg1: &mut GlobalConfig)
88ImmBorrowField[12](GlobalConfig.total_pools_created: u64)
89ReadRef
90LdU64(1)
91Add
92MoveLoc[1](Arg1: &mut GlobalConfig)
93MutBorrowField[12](GlobalConfig.total_pools_created: u64)
94WriteRef
95MutBorrowLoc[28](loc18: LiquidityPool<Ty0>)
96MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
97LdFalse
98Pack[34](IdealBaseAnchorKey)
99LdU64(0)
100Call dynamic_field::add<IdealBaseAnchorKey, u64>(&mut UID, IdealBaseAnchorKey, u64)
101MutBorrowLoc[28](loc18: LiquidityPool<Ty0>)
102MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
103LdFalse
104Pack[36](FlashSwapEnabledKey)
105LdTrue
106Call dynamic_field::add<FlashSwapEnabledKey, bool>(&mut UID, FlashSwapEnabledKey, bool)
107ImmBorrowLoc[28](loc18: LiquidityPool<Ty0>)
108Call default_flash_swap_protocol_fee<Ty0>(&LiquidityPool<Ty0>): u64
109StLoc[27](loc17: u64)
110MutBorrowLoc[28](loc18: LiquidityPool<Ty0>)
111MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
112LdFalse
113Pack[37](FlashSwapProtocolFeeKey)
114MoveLoc[27](loc17: u64)
115Call dynamic_field::add<FlashSwapProtocolFeeKey, u64>(&mut UID, FlashSwapProtocolFeeKey, u64)
116ImmBorrowLoc[28](loc18: LiquidityPool<Ty0>)
117ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
118Call object::uid_to_inner(&UID): ID
119StLoc[29](loc19: ID)
120ImmBorrowLoc[28](loc18: LiquidityPool<Ty0>)
121ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
122Call object::uid_to_inner(&UID): ID
123Call type_name::with_defining_ids<Ty0>(): TypeName
124MoveLoc[30](loc20: address)
125LdTrue
126Pack[15](PoolCreated)
127Call event::emit<PoolCreated>(PoolCreated)
128MoveLoc[28](loc18: LiquidityPool<Ty0>)
129Call transfer::share_object<LiquidityPool<Ty0>>(LiquidityPool<Ty0>)
130MoveLoc[29](loc19: ID)
131Ret
}
 
public update_config<Ty0>(Arg0: &GlobalConfig, Arg1: &mut LiquidityPool<Ty0>, Arg2: Option<u64>, Arg3: Option<u64>, Arg4: Option<u64>, Arg5: Option<u64>, Arg6: Option<u64>, Arg7: Option<u64>, Arg8: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
5ReadRef
6CopyLoc[8](Arg8: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Eq
10BrFalse(12)
B1:
11Branch(20)
B2:
12MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
13Pop
14MoveLoc[0](Arg0: &GlobalConfig)
15Pop
16MoveLoc[8](Arg8: &mut TxContext)
17Pop
18LdConst[2](u64: 4002)
19Abort
B3:
20MoveLoc[0](Arg0: &GlobalConfig)
21CopyLoc[2](Arg2: Option<u64>)
22CopyLoc[3](Arg3: Option<u64>)
23CopyLoc[4](Arg4: Option<u64>)
24CopyLoc[5](Arg5: Option<u64>)
25CopyLoc[6](Arg6: Option<u64>)
26Call assert_pool_fees(&GlobalConfig, Option<u64>, Option<u64>, Option<u64>, Option<u64>, Option<u64>)
27ImmBorrowLoc[2](Arg2: Option<u64>)
28Call option::is_some<u64>(&Option<u64>): bool
29BrFalse(36)
B4:
30ImmBorrowLoc[2](Arg2: Option<u64>)
31Call option::borrow<u64>(&Option<u64>): &u64
32ReadRef
33CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
34MutBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
35WriteRef
B5:
36ImmBorrowLoc[3](Arg3: Option<u64>)
37Call option::is_some<u64>(&Option<u64>): bool
38BrFalse(45)
B6:
39ImmBorrowLoc[3](Arg3: Option<u64>)
40Call option::borrow<u64>(&Option<u64>): &u64
41ReadRef
42CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
43MutBorrowFieldGeneric[7](LiquidityPool.lp_withdrawal_fee_pct: u64)
44WriteRef
B7:
45ImmBorrowLoc[4](Arg4: Option<u64>)
46Call option::is_some<u64>(&Option<u64>): bool
47BrFalse(54)
B8:
48ImmBorrowLoc[4](Arg4: Option<u64>)
49Call option::borrow<u64>(&Option<u64>): &u64
50ReadRef
51CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
52MutBorrowFieldGeneric[8](LiquidityPool.lp_fee_pct: u64)
53WriteRef
B9:
54ImmBorrowLoc[5](Arg5: Option<u64>)
55Call option::is_some<u64>(&Option<u64>): bool
56BrFalse(63)
B10:
57ImmBorrowLoc[5](Arg5: Option<u64>)
58Call option::borrow<u64>(&Option<u64>): &u64
59ReadRef
60CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
61MutBorrowFieldGeneric[9](LiquidityPool.max_dynamic_fee: u64)
62WriteRef
B11:
63ImmBorrowLoc[6](Arg6: Option<u64>)
64Call option::is_some<u64>(&Option<u64>): bool
65BrFalse(72)
B12:
66ImmBorrowLoc[6](Arg6: Option<u64>)
67Call option::borrow<u64>(&Option<u64>): &u64
68ReadRef
69CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
70MutBorrowFieldGeneric[10](LiquidityPool.limit_ratio: u64)
71WriteRef
B13:
72ImmBorrowLoc[7](Arg7: Option<u64>)
73Call option::is_some<u64>(&Option<u64>): bool
74BrFalse(81)
B14:
75ImmBorrowLoc[7](Arg7: Option<u64>)
76Call option::borrow<u64>(&Option<u64>): &u64
77ReadRef
78CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
79MutBorrowFieldGeneric[11](LiquidityPool.min_base_out: u64)
80WriteRef
B15:
81MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
82ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
83Call object::uid_to_inner(&UID): ID
84MoveLoc[2](Arg2: Option<u64>)
85MoveLoc[3](Arg3: Option<u64>)
86MoveLoc[4](Arg4: Option<u64>)
87MoveLoc[5](Arg5: Option<u64>)
88MoveLoc[6](Arg6: Option<u64>)
89MoveLoc[8](Arg8: &mut TxContext)
90FreezeRef
91Call tx_context::sender(&TxContext): address
92Pack[16](PoolConfigUpdated)
93Call event::emit<PoolConfigUpdated>(PoolConfigUpdated)
94Ret
}
 
public update_admin<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: address, Arg2: &mut TxContext) {
L3: loc0: address
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3MoveLoc[2](Arg2: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
8ReadRef
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
17ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
18ReadRef
19StLoc[3](loc0: address)
20CopyLoc[1](Arg1: address)
21CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
22MutBorrowFieldGeneric[5](LiquidityPool.admin: address)
23WriteRef
24MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
25ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
26Call object::uid_to_inner(&UID): ID
27MoveLoc[3](loc0: address)
28MoveLoc[1](Arg1: address)
29PackGeneric[2](AdminUpdated<Ty0>)
30Call event::emit<AdminUpdated<Ty0>>(AdminUpdated<Ty0>)
31Ret
}
 
public pause_market<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: String, Arg2: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
5ReadRef
6MoveLoc[2](Arg2: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16LdTrue
17CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
18MutBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
19WriteRef
20MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
21ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
22Call object::uid_to_inner(&UID): ID
23MoveLoc[1](Arg1: String)
24PackGeneric[3](MarketPausedEvent<Ty0>)
25Call event::emit<MarketPausedEvent<Ty0>>(MarketPausedEvent<Ty0>)
26Ret
}
 
public unpause_market<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
5ReadRef
6MoveLoc[1](Arg1: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16LdFalse
17CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
18MutBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
19WriteRef
20MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
21ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
22Call object::uid_to_inner(&UID): ID
23PackGeneric[4](MarketUnpausedEvent<Ty0>)
24Call event::emit<MarketUnpausedEvent<Ty0>>(MarketUnpausedEvent<Ty0>)
25Ret
}
 
public(friend) is_flash_swap_enabled<Ty0>(Arg0: &LiquidityPool<Ty0>): bool {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
2LdFalse
3Pack[36](FlashSwapEnabledKey)
4Call dynamic_field::borrow<FlashSwapEnabledKey, bool>(&UID, FlashSwapEnabledKey): &bool
5ReadRef
6Ret
}
 
public set_flash_swap_enabled<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: bool, Arg2: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
5ReadRef
6MoveLoc[2](Arg2: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16CopyLoc[1](Arg1: bool)
17CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
18MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
19LdFalse
20Pack[36](FlashSwapEnabledKey)
21Call dynamic_field::borrow_mut<FlashSwapEnabledKey, bool>(&mut UID, FlashSwapEnabledKey): &mut bool
22WriteRef
23MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
24ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
25Call object::uid_to_inner(&UID): ID
26MoveLoc[1](Arg1: bool)
27PackGeneric[5](FlashSwapEnabledSet<Ty0>)
28Call event::emit<FlashSwapEnabledSet<Ty0>>(FlashSwapEnabledSet<Ty0>)
29Ret
}
 
public(friend) flash_swap_protocol_fee<Ty0>(Arg0: &LiquidityPool<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
2LdFalse
3Pack[37](FlashSwapProtocolFeeKey)
4Call dynamic_field::borrow<FlashSwapProtocolFeeKey, u64>(&UID, FlashSwapProtocolFeeKey): &u64
5ReadRef
6Ret
}
 
entry set_flash_swap_protocol_fee<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: u64, Arg2: &TxContext) {
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
5ReadRef
6MoveLoc[2](Arg2: &TxContext)
7Call tx_context::sender(&TxContext): address
8Eq
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
12Pop
13LdConst[2](u64: 4002)
14Abort
B3:
15CopyLoc[1](Arg1: u64)
16CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
17MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
18LdFalse
19Pack[37](FlashSwapProtocolFeeKey)
20Call dynamic_field::borrow_mut<FlashSwapProtocolFeeKey, u64>(&mut UID, FlashSwapProtocolFeeKey): &mut u64
21WriteRef
22MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
23ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
24Call object::uid_to_inner(&UID): ID
25MoveLoc[1](Arg1: u64)
26PackGeneric[6](FlashSwapProtocolFeeSet<Ty0>)
27Call event::emit<FlashSwapProtocolFeeSet<Ty0>>(FlashSwapProtocolFeeSet<Ty0>)
28Ret
}
 
default_flash_swap_protocol_fee<Ty0>(Arg0: &LiquidityPool<Ty0>): u64 {
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
2ReadRef
3CastU128
4LdConst[32](u64: 10000)
5MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
6ImmBorrowFieldGeneric[8](LiquidityPool.lp_fee_pct: u64)
7ReadRef
8Sub
9CastU128
10LdConst[33](u128: 10000)
11Call math::mul_div_u128(u128, u128, u128): u128
12CastU64
13Ret
}
 
public withdraw_all_base<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut TxContext) {
L2: loc0: address
L3: loc1: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
2ReadRef
3CopyLoc[1](Arg1: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Eq
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
10Pop
11MoveLoc[1](Arg1: &mut TxContext)
12Pop
13LdConst[2](u64: 4002)
14Abort
B3:
15CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
16FreezeRef
17Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
18CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
19ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
20ReadRef
21StLoc[2](loc0: address)
22CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
23ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
24Call balance::value<Ty0>(&Balance<Ty0>): u64
25StLoc[3](loc1: u64)
26CopyLoc[3](loc1: u64)
27LdU64(0)
28Gt
29BrFalse(38)
B4:
30CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
31MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
32Call balance::withdraw_all<Ty0>(&mut Balance<Ty0>): Balance<Ty0>
33MoveLoc[1](Arg1: &mut TxContext)
34Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
35CopyLoc[2](loc0: address)
36Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
37Branch(40)
B5:
38MoveLoc[1](Arg1: &mut TxContext)
39Pop
B6:
40MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
41ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
42Call object::uid_to_inner(&UID): ID
43MoveLoc[2](loc0: address)
44MoveLoc[3](loc1: u64)
45PackGeneric[7](BaseWithdrawn<Ty0>)
46Call event::emit<BaseWithdrawn<Ty0>>(BaseWithdrawn<Ty0>)
47Ret
}
 
public withdraw_all_quote<Ty0, Ty1>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut TxContext) {
L2: loc0: address
L3: loc1: Balance<Ty1>
L4: loc2: ID
L5: loc3: u64
L6: loc4: String
L7: loc5: &mut QuoteAssetReserve<Ty1>
L8: loc6: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
2ReadRef
3CopyLoc[1](Arg1: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Eq
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
10Pop
11MoveLoc[1](Arg1: &mut TxContext)
12Pop
13LdConst[2](u64: 4002)
14Abort
B3:
15CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
16FreezeRef
17Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
18CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
19FreezeRef
20Call assert_quote_is_supported<Ty0, Ty1>(&LiquidityPool<Ty0>)
21CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
22ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
23ReadRef
24StLoc[2](loc0: address)
25CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
26ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
27Call object::uid_to_inner(&UID): ID
28StLoc[4](loc2: ID)
29Call type_name::with_defining_ids<Ty1>(): TypeName
30Call type_name::into_string(TypeName): String
31StLoc[6](loc4: String)
32MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
33MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
34CopyLoc[6](loc4: String)
35Call dynamic_field::borrow_mut<String, QuoteAssetReserve<Ty1>>(&mut UID, String): &mut QuoteAssetReserve<Ty1>
36StLoc[7](loc5: &mut QuoteAssetReserve<Ty1>)
37CopyLoc[7](loc5: &mut QuoteAssetReserve<Ty1>)
38ImmBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
39Call balance::value<Ty1>(&Balance<Ty1>): u64
40StLoc[5](loc3: u64)
41CopyLoc[7](loc5: &mut QuoteAssetReserve<Ty1>)
42ImmBorrowFieldGeneric[15](QuoteAssetReserve.collected_rewards: Balance<Ty1>)
43Call balance::value<Ty1>(&Balance<Ty1>): u64
44StLoc[8](loc6: u64)
45CopyLoc[7](loc5: &mut QuoteAssetReserve<Ty1>)
46MutBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
47Call balance::withdraw_all<Ty1>(&mut Balance<Ty1>): Balance<Ty1>
48StLoc[3](loc1: Balance<Ty1>)
49MutBorrowLoc[3](loc1: Balance<Ty1>)
50MoveLoc[7](loc5: &mut QuoteAssetReserve<Ty1>)
51MutBorrowFieldGeneric[15](QuoteAssetReserve.collected_rewards: Balance<Ty1>)
52Call balance::withdraw_all<Ty1>(&mut Balance<Ty1>): Balance<Ty1>
53Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
54Pop
55ImmBorrowLoc[3](loc1: Balance<Ty1>)
56Call balance::value<Ty1>(&Balance<Ty1>): u64
57LdU64(0)
58Gt
59BrFalse(66)
B4:
60MoveLoc[3](loc1: Balance<Ty1>)
61MoveLoc[1](Arg1: &mut TxContext)
62Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
63CopyLoc[2](loc0: address)
64Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)
65Branch(70)
B5:
66MoveLoc[1](Arg1: &mut TxContext)
67Pop
68MoveLoc[3](loc1: Balance<Ty1>)
69Call balance::destroy_zero<Ty1>(Balance<Ty1>)
B6:
70MoveLoc[4](loc2: ID)
71MoveLoc[2](loc0: address)
72MoveLoc[6](loc4: String)
73MoveLoc[5](loc3: u64)
74MoveLoc[8](loc6: u64)
75PackGeneric[8](QuoteWithdrawn<Ty0, Ty1>)
76Call event::emit<QuoteWithdrawn<Ty0, Ty1>>(QuoteWithdrawn<Ty0, Ty1>)
77Ret
}
 
public add_to_whitelist<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: vector<address>, Arg2: &mut TxContext) {
L3: loc0: address
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3MoveLoc[2](Arg2: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
8ReadRef
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16ImmBorrowLoc[1](Arg1: vector<address>)
17VecLen(81)
18LdU64(0)
19Gt
20BrFalse(35)
B4:
21MutBorrowLoc[1](Arg1: vector<address>)
22VecPopBack(81)
23StLoc[3](loc0: address)
24CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
25ImmBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
26ImmBorrowLoc[3](loc0: address)
27Call vector::contains<address>(&vector<address>, &address): bool
28Not
29BrFalse(16)
B5:
30CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
31MutBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
32MoveLoc[3](loc0: address)
33VecPushBack(81)
34Branch(16)
B6:
35CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
36ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
37Call object::uid_to_inner(&UID): ID
38MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
39ImmBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
40ReadRef
41PackGeneric[9](LPWhitelisted<Ty0>)
42Call event::emit<LPWhitelisted<Ty0>>(LPWhitelisted<Ty0>)
43Ret
}
 
public remove_from_whitelist<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: vector<address>, Arg2: &mut TxContext) {
L3: loc0: u64
L4: loc1: address
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3MoveLoc[2](Arg2: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
8ReadRef
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16ImmBorrowLoc[1](Arg1: vector<address>)
17VecLen(81)
18LdU64(0)
19Gt
20BrFalse(36)
B4:
21MutBorrowLoc[1](Arg1: vector<address>)
22VecPopBack(81)
23StLoc[4](loc1: address)
24CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
25ImmBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
26ImmBorrowLoc[4](loc1: address)
27Call vector::index_of<address>(&vector<address>, &address): bool * u64
28StLoc[3](loc0: u64)
29BrFalse(16)
B5:
30CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
31MutBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
32MoveLoc[3](loc0: u64)
33Call vector::remove<address>(&mut vector<address>, u64): address
34Pop
35Branch(16)
B6:
36CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
37ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
38Call object::uid_to_inner(&UID): ID
39MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
40ImmBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
41ReadRef
42PackGeneric[10](LpRemovedFromWhitelist<Ty0>)
43Call event::emit<LpRemovedFromWhitelist<Ty0>>(LpRemovedFromWhitelist<Ty0>)
44Ret
}
 
public set_permissioned<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: bool, Arg2: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3MoveLoc[2](Arg2: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
8ReadRef
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16CopyLoc[1](Arg1: bool)
17CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
18MutBorrowFieldGeneric[17](LiquidityPool.is_permissioned: bool)
19WriteRef
20MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
21ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
22Call object::uid_to_inner(&UID): ID
23MoveLoc[1](Arg1: bool)
24PackGeneric[11](PoolPermissionUpdated<Ty0>)
25Call event::emit<PoolPermissionUpdated<Ty0>>(PoolPermissionUpdated<Ty0>)
26Ret
}
 
assert_valid_quote_asset_config(Arg0: u64, Arg1: u64, Arg2: u64, Arg3: u64) {
B0:
0CopyLoc[0](Arg0: u64)
1LdConst[32](u64: 10000)
2Le
3BrFalse(5)
B1:
4Branch(7)
B2:
5LdConst[8](u64: 4010)
6Abort
B3:
7CopyLoc[1](Arg1: u64)
8LdConst[32](u64: 10000)
9Le
10BrFalse(12)
B4:
11Branch(14)
B5:
12LdConst[8](u64: 4010)
13Abort
B6:
14CopyLoc[2](Arg2: u64)
15LdConst[32](u64: 10000)
16Le
17BrFalse(19)
B7:
18Branch(21)
B8:
19LdConst[8](u64: 4010)
20Abort
B9:
21CopyLoc[3](Arg3: u64)
22LdConst[32](u64: 10000)
23Le
24BrFalse(26)
B10:
25Branch(28)
B11:
26LdConst[8](u64: 4010)
27Abort
B12:
28MoveLoc[0](Arg0: u64)
29MoveLoc[1](Arg1: u64)
30Le
31BrFalse(33)
B13:
32Branch(35)
B14:
33LdConst[8](u64: 4010)
34Abort
B15:
35MoveLoc[2](Arg2: u64)
36MoveLoc[3](Arg3: u64)
37Le
38BrFalse(40)
B16:
39Branch(42)
B17:
40LdConst[8](u64: 4010)
41Abort
B18:
42Ret
}
 
public add_quote_asset<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut LiquidityPool<Ty0>, Arg2: &mut Oracle, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: Option<u64>, Arg8: Option<u64>, Arg9: u64, Arg10: &mut TxContext) {
L11: loc0: bool
L12: loc1: Option<u64>
L13: loc2: Option<u64>
L14: loc3: Option<u64>
L15: loc4: Option<u64>
L16: loc5: String
L17: loc6: QuoteAssetReserve<Ty1>
B0:
0CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[10](Arg10: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
8ReadRef
9Eq
10BrFalse(12)
B1:
11Branch(22)
B2:
12MoveLoc[2](Arg2: &mut Oracle)
13Pop
14MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
15Pop
16MoveLoc[10](Arg10: &mut TxContext)
17Pop
18MoveLoc[0](Arg0: &GlobalConfig)
19Pop
20LdConst[2](u64: 4002)
21Abort
B3:
22CopyLoc[3](Arg3: u64)
23CopyLoc[4](Arg4: u64)
24CopyLoc[5](Arg5: u64)
25CopyLoc[6](Arg6: u64)
26Call assert_valid_quote_asset_config(u64, u64, u64, u64)
27Call type_name::with_defining_ids<Ty0>(): TypeName
28Call type_name::with_defining_ids<Ty1>(): TypeName
29Neq
30BrFalse(32)
B4:
31Branch(42)
B5:
32MoveLoc[2](Arg2: &mut Oracle)
33Pop
34MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
35Pop
36MoveLoc[10](Arg10: &mut TxContext)
37Pop
38MoveLoc[0](Arg0: &GlobalConfig)
39Pop
40LdConst[21](u64: 4024)
41Abort
B6:
42Call type_name::with_defining_ids<Ty1>(): TypeName
43Call type_name::into_string(TypeName): String
44StLoc[16](loc5: String)
45CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
46ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
47CopyLoc[16](loc5: String)
48Call dynamic_field::exists_<String>(&UID, String): bool
49Not
50BrFalse(52)
B7:
51Branch(62)
B8:
52MoveLoc[2](Arg2: &mut Oracle)
53Pop
54MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
55Pop
56MoveLoc[10](Arg10: &mut TxContext)
57Pop
58MoveLoc[0](Arg0: &GlobalConfig)
59Pop
60LdConst[20](u64: 4023)
61Abort
B9:
62CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
63ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
64ImmBorrowLoc[16](loc5: String)
65Call vector::contains<String>(&vector<String>, &String): bool
66Not
67BrFalse(72)
B10:
68CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
69MutBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
70CopyLoc[16](loc5: String)
71VecPushBack(128)
B11:
72CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
73ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
74VecLen(128)
75MoveLoc[0](Arg0: &GlobalConfig)
76ImmBorrowField[3](GlobalConfig.max_quote_assets_per_pool: u64)
77ReadRef
78Le
79BrFalse(81)
B12:
80Branch(89)
B13:
81MoveLoc[2](Arg2: &mut Oracle)
82Pop
83MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
84Pop
85MoveLoc[10](Arg10: &mut TxContext)
86Pop
87LdConst[11](u64: 4013)
88Abort
B14:
89CopyLoc[2](Arg2: &mut Oracle)
90Call price_oracle::check_asset_pair_exists<Ty0, Ty1>(&mut Oracle): bool
91BrFalse(96)
B15:
92MoveLoc[2](Arg2: &mut Oracle)
93Call price_oracle::check_asset_pair_exists<Ty1, Ty0>(&mut Oracle): bool
94StLoc[11](loc0: bool)
95Branch(100)
B16:
96MoveLoc[2](Arg2: &mut Oracle)
97Pop
98LdFalse
99StLoc[11](loc0: bool)
B17:
100MoveLoc[11](loc0: bool)
101BrFalse(103)
B18:
102Branch(109)
B19:
103MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
104Pop
105MoveLoc[10](Arg10: &mut TxContext)
106Pop
107LdConst[12](u64: 4014)
108Abort
B20:
109ImmBorrowLoc[7](Arg7: Option<u64>)
110Call option::is_some<u64>(&Option<u64>): bool
111BrFalse(118)
B21:
112ImmBorrowLoc[7](Arg7: Option<u64>)
113Call option::borrow<u64>(&Option<u64>): &u64
114ReadRef
115Call option::some<u64>(u64): Option<u64>
116StLoc[12](loc1: Option<u64>)
117Branch(120)
B22:
118Call option::none<u64>(): Option<u64>
119StLoc[12](loc1: Option<u64>)
B23:
120MoveLoc[12](loc1: Option<u64>)
121StLoc[15](loc4: Option<u64>)
122ImmBorrowLoc[8](Arg8: Option<u64>)
123Call option::is_some<u64>(&Option<u64>): bool
124BrFalse(131)
B24:
125ImmBorrowLoc[8](Arg8: Option<u64>)
126Call option::borrow<u64>(&Option<u64>): &u64
127ReadRef
128Call option::some<u64>(u64): Option<u64>
129StLoc[13](loc2: Option<u64>)
130Branch(133)
B25:
131Call option::none<u64>(): Option<u64>
132StLoc[13](loc2: Option<u64>)
B26:
133MoveLoc[13](loc2: Option<u64>)
134StLoc[14](loc3: Option<u64>)
135Call balance::zero<Ty1>(): Balance<Ty1>
136Call balance::zero<Ty1>(): Balance<Ty1>
137CopyLoc[3](Arg3: u64)
138CopyLoc[4](Arg4: u64)
139LdU128(0)
140CopyLoc[5](Arg5: u64)
141CopyLoc[6](Arg6: u64)
142CopyLoc[9](Arg9: u64)
143CopyLoc[15](loc4: Option<u64>)
144CopyLoc[14](loc3: Option<u64>)
145LdTrue
146PackGeneric[12](QuoteAssetReserve<Ty1>)
147StLoc[17](loc6: QuoteAssetReserve<Ty1>)
148CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
149MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
150CopyLoc[16](loc5: String)
151MoveLoc[17](loc6: QuoteAssetReserve<Ty1>)
152Call dynamic_field::add<String, QuoteAssetReserve<Ty1>>(&mut UID, String, QuoteAssetReserve<Ty1>)
153CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
154ImmBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
155CopyLoc[16](loc5: String)
156Call table::contains<String, u128>(&Table<String, u128>, String): bool
157Not
158BrFalse(164)
B27:
159CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
160MutBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
161CopyLoc[16](loc5: String)
162LdU128(0)
163Call table::add<String, u128>(&mut Table<String, u128>, String, u128)
B28:
164MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
165ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
166Call object::uid_to_inner(&UID): ID
167MoveLoc[16](loc5: String)
168MoveLoc[3](Arg3: u64)
169MoveLoc[4](Arg4: u64)
170MoveLoc[5](Arg5: u64)
171MoveLoc[6](Arg6: u64)
172MoveLoc[15](loc4: Option<u64>)
173MoveLoc[14](loc3: Option<u64>)
174MoveLoc[9](Arg9: u64)
175MoveLoc[10](Arg10: &mut TxContext)
176FreezeRef
177Call tx_context::sender(&TxContext): address
178PackGeneric[13](QuoteAssetAdded<Ty0, Ty1>)
179Call event::emit<QuoteAssetAdded<Ty0, Ty1>>(QuoteAssetAdded<Ty0, Ty1>)
180Ret
}
 
public update_quote_asset<Ty0, Ty1>(Arg0: &mut LiquidityPool<Ty0>, Arg1: Option<u64>, Arg2: Option<u64>, Arg3: Option<u64>, Arg4: Option<u64>, Arg5: Option<u64>, Arg6: Option<u64>, Arg7: Option<u64>, Arg8: Option<bool>, Arg9: &mut TxContext) {
L10: loc0: ID
L11: loc1: String
L12: loc2: &mut QuoteAssetReserve<Ty1>
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[9](Arg9: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
8ReadRef
9Eq
10BrFalse(12)
B1:
11Branch(18)
B2:
12MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13Pop
14MoveLoc[9](Arg9: &mut TxContext)
15Pop
16LdConst[2](u64: 4002)
17Abort
B3:
18CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
19ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
20Call object::uid_to_inner(&UID): ID
21StLoc[10](loc0: ID)
22Call type_name::with_defining_ids<Ty1>(): TypeName
23Call type_name::into_string(TypeName): String
24StLoc[11](loc1: String)
25CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
26ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
27CopyLoc[11](loc1: String)
28Call dynamic_field::exists_<String>(&UID, String): bool
29BrFalse(31)
B4:
30Branch(37)
B5:
31MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
32Pop
33MoveLoc[9](Arg9: &mut TxContext)
34Pop
35LdConst[3](u64: 4003)
36Abort
B6:
37MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
38MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
39CopyLoc[11](loc1: String)
40Call dynamic_field::borrow_mut<String, QuoteAssetReserve<Ty1>>(&mut UID, String): &mut QuoteAssetReserve<Ty1>
41StLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
42ImmBorrowLoc[1](Arg1: Option<u64>)
43Call option::is_some<u64>(&Option<u64>): bool
44BrFalse(51)
B7:
45ImmBorrowLoc[1](Arg1: Option<u64>)
46Call option::borrow<u64>(&Option<u64>): &u64
47ReadRef
48CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
49MutBorrowFieldGeneric[18](QuoteAssetReserve.ideal_reserve_pct: u64)
50WriteRef
B8:
51ImmBorrowLoc[2](Arg2: Option<u64>)
52Call option::is_some<u64>(&Option<u64>): bool
53BrFalse(60)
B9:
54ImmBorrowLoc[2](Arg2: Option<u64>)
55Call option::borrow<u64>(&Option<u64>): &u64
56ReadRef
57CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
58MutBorrowFieldGeneric[19](QuoteAssetReserve.max_reserve_pct: u64)
59WriteRef
B10:
60ImmBorrowLoc[3](Arg3: Option<u64>)
61Call option::is_some<u64>(&Option<u64>): bool
62BrFalse(69)
B11:
63ImmBorrowLoc[3](Arg3: Option<u64>)
64Call option::borrow<u64>(&Option<u64>): &u64
65ReadRef
66CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
67MutBorrowFieldGeneric[20](QuoteAssetReserve.fee_base: u64)
68WriteRef
B12:
69ImmBorrowLoc[4](Arg4: Option<u64>)
70Call option::is_some<u64>(&Option<u64>): bool
71BrFalse(78)
B13:
72ImmBorrowLoc[4](Arg4: Option<u64>)
73Call option::borrow<u64>(&Option<u64>): &u64
74ReadRef
75CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
76MutBorrowFieldGeneric[21](QuoteAssetReserve.fee_max: u64)
77WriteRef
B14:
78ImmBorrowLoc[5](Arg5: Option<u64>)
79Call option::is_some<u64>(&Option<u64>): bool
80BrFalse(88)
B15:
81ImmBorrowLoc[5](Arg5: Option<u64>)
82Call option::borrow<u64>(&Option<u64>): &u64
83ReadRef
84Call option::some<u64>(u64): Option<u64>
85CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
86MutBorrowFieldGeneric[22](QuoteAssetReserve.limit_ratio: Option<u64>)
87WriteRef
B16:
88ImmBorrowLoc[6](Arg6: Option<u64>)
89Call option::is_some<u64>(&Option<u64>): bool
90BrFalse(98)
B17:
91ImmBorrowLoc[6](Arg6: Option<u64>)
92Call option::borrow<u64>(&Option<u64>): &u64
93ReadRef
94Call option::some<u64>(u64): Option<u64>
95CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
96MutBorrowFieldGeneric[23](QuoteAssetReserve.limit_fixed: Option<u64>)
97WriteRef
B18:
98ImmBorrowLoc[7](Arg7: Option<u64>)
99Call option::is_some<u64>(&Option<u64>): bool
100BrFalse(107)
B19:
101ImmBorrowLoc[7](Arg7: Option<u64>)
102Call option::borrow<u64>(&Option<u64>): &u64
103ReadRef
104CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
105MutBorrowFieldGeneric[24](QuoteAssetReserve.min_out: u64)
106WriteRef
B20:
107ImmBorrowLoc[8](Arg8: Option<bool>)
108Call option::is_some<bool>(&Option<bool>): bool
109BrFalse(116)
B21:
110ImmBorrowLoc[8](Arg8: Option<bool>)
111Call option::borrow<bool>(&Option<bool>): &bool
112ReadRef
113CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
114MutBorrowFieldGeneric[25](QuoteAssetReserve.is_trading: bool)
115WriteRef
B22:
116CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
117ImmBorrowFieldGeneric[18](QuoteAssetReserve.ideal_reserve_pct: u64)
118ReadRef
119CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
120ImmBorrowFieldGeneric[19](QuoteAssetReserve.max_reserve_pct: u64)
121ReadRef
122CopyLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
123ImmBorrowFieldGeneric[20](QuoteAssetReserve.fee_base: u64)
124ReadRef
125MoveLoc[12](loc2: &mut QuoteAssetReserve<Ty1>)
126ImmBorrowFieldGeneric[21](QuoteAssetReserve.fee_max: u64)
127ReadRef
128Call assert_valid_quote_asset_config(u64, u64, u64, u64)
129MoveLoc[10](loc0: ID)
130MoveLoc[11](loc1: String)
131MoveLoc[1](Arg1: Option<u64>)
132MoveLoc[2](Arg2: Option<u64>)
133MoveLoc[3](Arg3: Option<u64>)
134MoveLoc[4](Arg4: Option<u64>)
135MoveLoc[5](Arg5: Option<u64>)
136MoveLoc[6](Arg6: Option<u64>)
137MoveLoc[7](Arg7: Option<u64>)
138MoveLoc[8](Arg8: Option<bool>)
139MoveLoc[9](Arg9: &mut TxContext)
140FreezeRef
141Call tx_context::sender(&TxContext): address
142PackGeneric[14](QuoteAssetUpdated<Ty0, Ty1>)
143Call event::emit<QuoteAssetUpdated<Ty0, Ty1>>(QuoteAssetUpdated<Ty0, Ty1>)
144Ret
}
 
public initial_deposit_base<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: Coin<Ty0>, Arg2: u64, Arg3: &mut TxContext) {
L4: loc0: Table<String, u64>
L5: loc1: u64
L6: loc2: LPPosition<Ty0>
L7: loc3: Table<String, u128>
L8: loc4: String
L9: loc5: u128
L10: loc6: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
2ReadRef
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7Pop
8MoveLoc[3](Arg3: &mut TxContext)
9Pop
10LdConst[4](u64: 4005)
11Abort
B3:
12CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
13FreezeRef
14Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
15ImmBorrowLoc[1](Arg1: Coin<Ty0>)
16Call coin::value<Ty0>(&Coin<Ty0>): u64
17CopyLoc[2](Arg2: u64)
18Ge
19BrFalse(21)
B4:
20Branch(27)
B5:
21MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
22Pop
23MoveLoc[3](Arg3: &mut TxContext)
24Pop
25LdConst[1](u64: 4001)
26Abort
B6:
27CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
28MutBorrowLoc[1](Arg1: Coin<Ty0>)
29MoveLoc[2](Arg2: u64)
30CopyLoc[3](Arg3: &mut TxContext)
31Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
32LdTrue
33CopyLoc[3](Arg3: &mut TxContext)
34FreezeRef
35Call internal_deposit_base<Ty0>(&mut LiquidityPool<Ty0>, Coin<Ty0>, bool, &TxContext): u64
36StLoc[10](loc6: u64)
37CopyLoc[3](Arg3: &mut TxContext)
38Call table::new<String, u128>(&mut TxContext): Table<String, u128>
39StLoc[7](loc3: Table<String, u128>)
40CopyLoc[3](Arg3: &mut TxContext)
41Call table::new<String, u64>(&mut TxContext): Table<String, u64>
42StLoc[4](loc0: Table<String, u64>)
43LdU64(0)
44StLoc[5](loc1: u64)
B7:
45CopyLoc[5](loc1: u64)
46CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
47ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
48VecLen(128)
49Lt
50BrFalse(76)
B8:
51CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
52ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
53CopyLoc[5](loc1: u64)
54VecImmBorrow(128)
55ReadRef
56StLoc[8](loc4: String)
57CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
58ImmBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
59CopyLoc[8](loc4: String)
60Call table::borrow<String, u128>(&Table<String, u128>, String): &u128
61ReadRef
62StLoc[9](loc5: u128)
63MutBorrowLoc[7](loc3: Table<String, u128>)
64CopyLoc[8](loc4: String)
65MoveLoc[9](loc5: u128)
66Call table::add<String, u128>(&mut Table<String, u128>, String, u128)
67MutBorrowLoc[4](loc0: Table<String, u64>)
68MoveLoc[8](loc4: String)
69LdU64(0)
70Call table::add<String, u64>(&mut Table<String, u64>, String, u64)
71MoveLoc[5](loc1: u64)
72LdU64(1)
73Add
74StLoc[5](loc1: u64)
75Branch(45)
B9:
76CopyLoc[3](Arg3: &mut TxContext)
77Call object::new(&mut TxContext): UID
78MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
79ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
80Call object::uid_to_inner(&UID): ID
81MoveLoc[10](loc6: u64)
82MoveLoc[7](loc3: Table<String, u128>)
83MoveLoc[4](loc0: Table<String, u64>)
84PackGeneric[15](LPPosition<Ty0>)
85StLoc[6](loc2: LPPosition<Ty0>)
86MoveLoc[1](Arg1: Coin<Ty0>)
87CopyLoc[3](Arg3: &mut TxContext)
88FreezeRef
89Call tx_context::sender(&TxContext): address
90Call helper::transfer_or_destroy_zero<Ty0>(Coin<Ty0>, address): bool
91Pop
92MoveLoc[6](loc2: LPPosition<Ty0>)
93MoveLoc[3](Arg3: &mut TxContext)
94FreezeRef
95Call tx_context::sender(&TxContext): address
96Call transfer::public_transfer<LPPosition<Ty0>>(LPPosition<Ty0>, address)
97Ret
}
 
public deposit_base<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut LPPosition<Ty0>, Arg2: Coin<Ty0>, Arg3: u64, Arg4: &mut TxContext) {
L5: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
2ReadRef
3Not
4BrFalse(6)
B1:
5Branch(14)
B2:
6MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
7Pop
8MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
9Pop
10MoveLoc[4](Arg4: &mut TxContext)
11Pop
12LdConst[4](u64: 4005)
13Abort
B3:
14CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
15FreezeRef
16Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
17ImmBorrowLoc[2](Arg2: Coin<Ty0>)
18Call coin::value<Ty0>(&Coin<Ty0>): u64
19CopyLoc[3](Arg3: u64)
20Ge
21BrFalse(23)
B4:
22Branch(31)
B5:
23MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
24Pop
25MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
26Pop
27MoveLoc[4](Arg4: &mut TxContext)
28Pop
29LdConst[1](u64: 4001)
30Abort
B6:
31CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
32ImmBorrowFieldGeneric[26](LPPosition.pool_id: ID)
33ReadRef
34CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
35ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
36Call object::uid_to_inner(&UID): ID
37Eq
38BrFalse(40)
B7:
39Branch(48)
B8:
40MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
41Pop
42MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
43Pop
44MoveLoc[4](Arg4: &mut TxContext)
45Pop
46LdConst[10](u64: 4012)
47Abort
B9:
48CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
49FreezeRef
50CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
51Call update_claimable_rewards_inner<Ty0>(&LiquidityPool<Ty0>, &mut LPPosition<Ty0>)
52MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
53MutBorrowLoc[2](Arg2: Coin<Ty0>)
54MoveLoc[3](Arg3: u64)
55CopyLoc[4](Arg4: &mut TxContext)
56Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
57LdFalse
58CopyLoc[4](Arg4: &mut TxContext)
59FreezeRef
60Call internal_deposit_base<Ty0>(&mut LiquidityPool<Ty0>, Coin<Ty0>, bool, &TxContext): u64
61StLoc[5](loc0: u64)
62MoveLoc[2](Arg2: Coin<Ty0>)
63MoveLoc[4](Arg4: &mut TxContext)
64FreezeRef
65Call tx_context::sender(&TxContext): address
66Call helper::transfer_or_destroy_zero<Ty0>(Coin<Ty0>, address): bool
67Pop
68CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
69ImmBorrowFieldGeneric[27](LPPosition.shares: u64)
70ReadRef
71MoveLoc[5](loc0: u64)
72Add
73MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
74MutBorrowFieldGeneric[27](LPPosition.shares: u64)
75WriteRef
76Ret
}
 
public claimable_rewards_info_inner(Arg0: &ClaimableRewardsInfo): String * u64 * u128 * u128 {
B0:
0CopyLoc[0](Arg0: &ClaimableRewardsInfo)
1ImmBorrowField[36](ClaimableRewardsInfo.asset: String)
2ReadRef
3CopyLoc[0](Arg0: &ClaimableRewardsInfo)
4ImmBorrowField[37](ClaimableRewardsInfo.amount: u64)
5ReadRef
6CopyLoc[0](Arg0: &ClaimableRewardsInfo)
7ImmBorrowField[38](ClaimableRewardsInfo.reward_rps: u128)
8ReadRef
9MoveLoc[0](Arg0: &ClaimableRewardsInfo)
10ImmBorrowField[39](ClaimableRewardsInfo.paid_rps: u128)
11ReadRef
12Ret
}
 
public calc_claimable_rewards<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: &LPPosition<Ty0>, Arg2: u64): ClaimableRewardsInfo {
L3: loc0: u128
L4: loc1: u64
L5: loc2: u128
L6: loc3: String
L7: loc4: u128
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
2MoveLoc[2](Arg2: u64)
3VecImmBorrow(128)
4ReadRef
5StLoc[6](loc3: String)
6MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
8CopyLoc[6](loc3: String)
9Call table::borrow<String, u128>(&Table<String, u128>, String): &u128
10ReadRef
11StLoc[7](loc4: u128)
12CopyLoc[1](Arg1: &LPPosition<Ty0>)
13ImmBorrowFieldGeneric[28](LPPosition.paid_rps: Table<String, u128>)
14CopyLoc[6](loc3: String)
15Call table::contains<String, u128>(&Table<String, u128>, String): bool
16BrFalse(24)
B1:
17CopyLoc[1](Arg1: &LPPosition<Ty0>)
18ImmBorrowFieldGeneric[28](LPPosition.paid_rps: Table<String, u128>)
19CopyLoc[6](loc3: String)
20Call table::borrow<String, u128>(&Table<String, u128>, String): &u128
21ReadRef
22StLoc[3](loc0: u128)
23Branch(26)
B2:
24LdU128(0)
25StLoc[3](loc0: u128)
B3:
26MoveLoc[3](loc0: u128)
27StLoc[5](loc2: u128)
28CopyLoc[7](loc4: u128)
29CopyLoc[5](loc2: u128)
30Sub
31CopyLoc[1](Arg1: &LPPosition<Ty0>)
32ImmBorrowFieldGeneric[27](LPPosition.shares: u64)
33ReadRef
34CastU128
35LdConst[31](u128: 1000..)
36CastU128
37Call math::mul_div_u128(u128, u128, u128): u128
38CastU64
39StLoc[4](loc1: u64)
40CopyLoc[1](Arg1: &LPPosition<Ty0>)
41ImmBorrowFieldGeneric[29](LPPosition.claimable_rewards: Table<String, u64>)
42CopyLoc[6](loc3: String)
43Call table::contains<String, u64>(&Table<String, u64>, String): bool
44BrFalse(54)
B4:
45MoveLoc[1](Arg1: &LPPosition<Ty0>)
46ImmBorrowFieldGeneric[29](LPPosition.claimable_rewards: Table<String, u64>)
47CopyLoc[6](loc3: String)
48Call table::borrow<String, u64>(&Table<String, u64>, String): &u64
49ReadRef
50MoveLoc[4](loc1: u64)
51Add
52StLoc[4](loc1: u64)
53Branch(56)
B5:
54MoveLoc[1](Arg1: &LPPosition<Ty0>)
55Pop
B6:
56MoveLoc[6](loc3: String)
57MoveLoc[4](loc1: u64)
58MoveLoc[7](loc4: u128)
59MoveLoc[5](loc2: u128)
60Pack[38](ClaimableRewardsInfo)
61Ret
}
 
update_claimable_rewards_inner<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: &mut LPPosition<Ty0>) {
L2: loc0: ClaimableRewardsInfo
L3: loc1: u64
B0:
0LdU64(0)
1StLoc[3](loc1: u64)
B1:
2CopyLoc[3](loc1: u64)
3CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
5VecLen(128)
6Lt
7BrFalse(38)
B2:
8Branch(9)
B3:
9CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
10CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
11FreezeRef
12CopyLoc[3](loc1: u64)
13Call calc_claimable_rewards<Ty0>(&LiquidityPool<Ty0>, &LPPosition<Ty0>, u64): ClaimableRewardsInfo
14StLoc[2](loc0: ClaimableRewardsInfo)
15CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
16MutBorrowFieldGeneric[29](LPPosition.claimable_rewards: Table<String, u64>)
17ImmBorrowLoc[2](loc0: ClaimableRewardsInfo)
18ImmBorrowField[36](ClaimableRewardsInfo.asset: String)
19ReadRef
20ImmBorrowLoc[2](loc0: ClaimableRewardsInfo)
21ImmBorrowField[37](ClaimableRewardsInfo.amount: u64)
22ReadRef
23Call table_upsert<u64>(&mut Table<String, u64>, String, u64)
24CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
25MutBorrowFieldGeneric[28](LPPosition.paid_rps: Table<String, u128>)
26ImmBorrowLoc[2](loc0: ClaimableRewardsInfo)
27ImmBorrowField[36](ClaimableRewardsInfo.asset: String)
28ReadRef
29ImmBorrowLoc[2](loc0: ClaimableRewardsInfo)
30ImmBorrowField[38](ClaimableRewardsInfo.reward_rps: u128)
31ReadRef
32Call table_upsert<u128>(&mut Table<String, u128>, String, u128)
33MoveLoc[3](loc1: u64)
34LdU64(1)
35Add
36StLoc[3](loc1: u64)
37Branch(2)
B4:
38MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
39Pop
40MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
41Pop
42Ret
}
 
internal_deposit_base<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: Coin<Ty0>, Arg2: bool, Arg3: &TxContext): u64 {
L4: loc0: Balance<Ty0>
L5: loc1: address
L6: loc2: u64
L7: loc3: u64
B0:
0MoveLoc[3](Arg3: &TxContext)
1Call tx_context::sender(&TxContext): address
2StLoc[5](loc1: address)
3ImmBorrowLoc[1](Arg1: Coin<Ty0>)
4Call coin::value<Ty0>(&Coin<Ty0>): u64
5StLoc[7](loc3: u64)
6CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[17](LiquidityPool.is_permissioned: bool)
8ReadRef
9BrFalse(20)
B1:
10CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
11ImmBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
12ImmBorrowLoc[5](loc1: address)
13Call vector::contains<address>(&vector<address>, &address): bool
14BrFalse(16)
B2:
15Branch(20)
B3:
16MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
17Pop
18LdConst[6](u64: 4008)
19Abort
B4:
20CopyLoc[7](loc3: u64)
21LdConst[34](u64: 1000)
22Mul
23StLoc[6](loc2: u64)
24CopyLoc[6](loc2: u64)
25LdU64(0)
26Gt
27BrFalse(29)
B5:
28Branch(33)
B6:
29MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
30Pop
31LdConst[29](u64: 4032)
32Abort
B7:
33MoveLoc[1](Arg1: Coin<Ty0>)
34Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
35StLoc[4](loc0: Balance<Ty0>)
36CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
37MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
38MoveLoc[4](loc0: Balance<Ty0>)
39Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
40Pop
41CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
42ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
43ReadRef
44CopyLoc[6](loc2: u64)
45Add
46CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
47MutBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
48WriteRef
49CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
50ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
51Call object::uid_to_inner(&UID): ID
52MoveLoc[5](loc1: address)
53MoveLoc[7](loc3: u64)
54CopyLoc[6](loc2: u64)
55MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
56ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
57ReadRef
58MoveLoc[2](Arg2: bool)
59PackGeneric[16](LiquidityAdded<Ty0>)
60Call event::emit<LiquidityAdded<Ty0>>(LiquidityAdded<Ty0>)
61MoveLoc[6](loc2: u64)
62Ret
}
 
public withdraw_base<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut LPPosition<Ty0>, Arg2: address, Arg3: &mut TxContext) {
L4: loc0: u64
B0:
0CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
1ImmBorrowFieldGeneric[27](LPPosition.shares: u64)
2ReadRef
3StLoc[4](loc0: u64)
4MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
5MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
6MoveLoc[4](loc0: u64)
7MoveLoc[2](Arg2: address)
8MoveLoc[3](Arg3: &mut TxContext)
9Call withdraw_shares<Ty0>(&mut LiquidityPool<Ty0>, &mut LPPosition<Ty0>, u64, address, &mut TxContext)
10Ret
}
 
public withdraw_shares<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut LPPosition<Ty0>, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
2MoveLoc[2](Arg2: u64)
3CopyLoc[3](Arg3: address)
4CopyLoc[4](Arg4: &mut TxContext)
5Call withdraw_shares_balance<Ty0>(&mut LiquidityPool<Ty0>, &mut LPPosition<Ty0>, u64, address, &mut TxContext): Balance<Ty0>
6MoveLoc[4](Arg4: &mut TxContext)
7Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
8MoveLoc[3](Arg3: address)
9Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
10Ret
}
 
public withdraw_shares_balance<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut LPPosition<Ty0>, Arg2: u64, Arg3: address, Arg4: &mut TxContext): Balance<Ty0> {
L5: loc0: Balance<Ty0>
L6: loc1: address
L7: loc2: Balance<Ty0>
L8: loc3: WithdrawSharesSimulationResult
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
2ReadRef
3Not
4BrFalse(6)
B1:
5Branch(14)
B2:
6MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
7Pop
8MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
9Pop
10MoveLoc[4](Arg4: &mut TxContext)
11Pop
12LdConst[4](u64: 4005)
13Abort
B3:
14CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
15FreezeRef
16Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
17CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
18FreezeRef
19CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
20FreezeRef
21CopyLoc[2](Arg2: u64)
22Call simulate_withdraw_shares<Ty0>(&LiquidityPool<Ty0>, &LPPosition<Ty0>, u64): WithdrawSharesSimulationResult
23StLoc[8](loc3: WithdrawSharesSimulationResult)
24CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
25MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
26ImmBorrowLoc[8](loc3: WithdrawSharesSimulationResult)
27ImmBorrowField[43](WithdrawSharesSimulationResult.base_out: u64)
28ReadRef
29Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
30StLoc[5](loc0: Balance<Ty0>)
31ImmBorrowLoc[8](loc3: WithdrawSharesSimulationResult)
32ImmBorrowField[44](WithdrawSharesSimulationResult.total_lp_shares: u64)
33ReadRef
34CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
35MutBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
36WriteRef
37CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
38MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
39ImmBorrowLoc[8](loc3: WithdrawSharesSimulationResult)
40ImmBorrowField[45](WithdrawSharesSimulationResult.base_fee: u64)
41ReadRef
42Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
43StLoc[7](loc2: Balance<Ty0>)
44CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
45MutBorrowFieldGeneric[2](LiquidityPool.protocol_base_fees: Balance<Ty0>)
46MoveLoc[7](loc2: Balance<Ty0>)
47Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
48Pop
49CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
50FreezeRef
51CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
52Call update_claimable_rewards_inner<Ty0>(&LiquidityPool<Ty0>, &mut LPPosition<Ty0>)
53CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
54ImmBorrowFieldGeneric[27](LPPosition.shares: u64)
55ReadRef
56CopyLoc[2](Arg2: u64)
57Sub
58MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
59MutBorrowFieldGeneric[27](LPPosition.shares: u64)
60WriteRef
61MoveLoc[4](Arg4: &mut TxContext)
62FreezeRef
63Call tx_context::sender(&TxContext): address
64StLoc[6](loc1: address)
65CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
66ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
67Call object::uid_to_inner(&UID): ID
68MoveLoc[6](loc1: address)
69ImmBorrowLoc[8](loc3: WithdrawSharesSimulationResult)
70ImmBorrowField[43](WithdrawSharesSimulationResult.base_out: u64)
71ReadRef
72MoveLoc[2](Arg2: u64)
73MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
74ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
75ReadRef
76PackGeneric[17](LiquidityRemoved<Ty0>)
77Call event::emit<LiquidityRemoved<Ty0>>(LiquidityRemoved<Ty0>)
78MoveLoc[5](loc0: Balance<Ty0>)
79Ret
}
 
public claim_rewards<Ty0, Ty1>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &mut LPPosition<Ty0>, Arg2: Option<address>, Arg3: &mut TxContext) {
L4: loc0: u64
L5: loc1: String
L6: loc2: address
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
2ReadRef
3Not
4BrFalse(6)
B1:
5Branch(14)
B2:
6MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
7Pop
8MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
9Pop
10MoveLoc[3](Arg3: &mut TxContext)
11Pop
12LdConst[4](u64: 4005)
13Abort
B3:
14Call type_name::with_defining_ids<Ty0>(): TypeName
15Call type_name::with_defining_ids<Ty1>(): TypeName
16Eq
17BrFalse(19)
B4:
18Branch(27)
B5:
19MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
20Pop
21MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
22Pop
23MoveLoc[3](Arg3: &mut TxContext)
24Pop
25LdConst[14](u64: 4017)
26Abort
B6:
27ImmBorrowLoc[2](Arg2: Option<address>)
28CopyLoc[3](Arg3: &mut TxContext)
29FreezeRef
30Call tx_context::sender(&TxContext): address
31Call option::get_with_default<address>(&Option<address>, address): address
32StLoc[6](loc2: address)
33CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
34FreezeRef
35Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
36CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
37ImmBorrowFieldGeneric[26](LPPosition.pool_id: ID)
38ReadRef
39CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
40ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
41Call object::uid_to_inner(&UID): ID
42Eq
43BrFalse(45)
B7:
44Branch(53)
B8:
45MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
46Pop
47MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
48Pop
49MoveLoc[3](Arg3: &mut TxContext)
50Pop
51LdConst[10](u64: 4012)
52Abort
B9:
53CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
54FreezeRef
55CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
56Call update_claimable_rewards_inner<Ty0>(&LiquidityPool<Ty0>, &mut LPPosition<Ty0>)
57Call type_name::with_defining_ids<Ty1>(): TypeName
58Call type_name::into_string(TypeName): String
59StLoc[5](loc1: String)
60CopyLoc[1](Arg1: &mut LPPosition<Ty0>)
61ImmBorrowFieldGeneric[29](LPPosition.claimable_rewards: Table<String, u64>)
62CopyLoc[5](loc1: String)
63Call table::borrow<String, u64>(&Table<String, u64>, String): &u64
64ReadRef
65StLoc[4](loc0: u64)
66CopyLoc[4](loc0: u64)
67LdU64(0)
68Gt
69BrFalse(93)
B10:
70Call type_name::with_defining_ids<Ty0>(): TypeName
71Call type_name::into_string(TypeName): String
72CopyLoc[5](loc1: String)
73Eq
74BrFalse(85)
B11:
75CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
76MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
77CopyLoc[4](loc0: u64)
78CastU64
79Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
80MoveLoc[3](Arg3: &mut TxContext)
81Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
82CopyLoc[6](loc2: address)
83Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
84Branch(87)
B12:
85MoveLoc[3](Arg3: &mut TxContext)
86Pop
B13:
87MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
88MutBorrowFieldGeneric[29](LPPosition.claimable_rewards: Table<String, u64>)
89CopyLoc[5](loc1: String)
90LdU64(0)
91Call table_upsert<u64>(&mut Table<String, u64>, String, u64)
92Branch(97)
B14:
93MoveLoc[1](Arg1: &mut LPPosition<Ty0>)
94Pop
95MoveLoc[3](Arg3: &mut TxContext)
96Pop
B15:
97MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
98ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
99Call object::uid_to_inner(&UID): ID
100MoveLoc[6](loc2: address)
101MoveLoc[5](loc1: String)
102MoveLoc[4](loc0: u64)
103PackGeneric[18](RewardsClaimed<Ty0, Ty1>)
104Call event::emit<RewardsClaimed<Ty0, Ty1>>(RewardsClaimed<Ty0, Ty1>)
105Ret
}
 
public swap_buy<Ty0, Ty1>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &Oracle, Arg2: &Clock, Arg3: Balance<Ty1>, Arg4: Option<u64>, Arg5: &mut TxContext): Balance<Ty0> * Balance<Ty1> {
L6: loc0: SwapSimulationResult
L7: loc1: u64
L8: loc2: Balance<Ty0>
L9: loc3: u64
L10: loc4: Balance<Ty0>
L11: loc5: u128
L12: loc6: u64
L13: loc7: u128
L14: loc8: u64
L15: loc9: u64
L16: loc10: String
L17: loc11: Balance<Ty1>
L18: loc12: u64
L19: loc13: &mut QuoteAssetReserve<Ty1>
L20: loc14: address
L21: loc15: u64
L22: loc16: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
2ReadRef
3Not
4BrFalse(6)
B1:
5Branch(16)
B2:
6MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7Pop
8MoveLoc[1](Arg1: &Oracle)
9Pop
10MoveLoc[5](Arg5: &mut TxContext)
11Pop
12MoveLoc[2](Arg2: &Clock)
13Pop
14LdConst[4](u64: 4005)
15Abort
B3:
16MoveLoc[5](Arg5: &mut TxContext)
17FreezeRef
18Call tx_context::sender(&TxContext): address
19StLoc[20](loc14: address)
20ImmBorrowLoc[3](Arg3: Balance<Ty1>)
21Call balance::value<Ty1>(&Balance<Ty1>): u64
22StLoc[15](loc9: u64)
23CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
24FreezeRef
25MoveLoc[1](Arg1: &Oracle)
26MoveLoc[2](Arg2: &Clock)
27CopyLoc[15](loc9: u64)
28Call simulate_buy_swap<Ty0, Ty1>(&LiquidityPool<Ty0>, &Oracle, &Clock, u64): SwapSimulationResult
29StLoc[6](loc0: SwapSimulationResult)
30ImmBorrowLoc[6](loc0: SwapSimulationResult)
31Call simulation_result_inner(&SwapSimulationResult): u64 * u64 * u64 * u64 * u128 * u64 * u64 * u64 * u128
32StLoc[13](loc7: u128)
33StLoc[14](loc8: u64)
34StLoc[12](loc6: u64)
35StLoc[21](loc15: u64)
36StLoc[11](loc5: u128)
37StLoc[9](loc3: u64)
38StLoc[22](loc16: u64)
39Pop
40StLoc[7](loc1: u64)
41CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
42FreezeRef
43Call assert_quote_is_trading<Ty0, Ty1>(&LiquidityPool<Ty0>)
44CopyLoc[7](loc1: u64)
45CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
46ImmBorrowFieldGeneric[11](LiquidityPool.min_base_out: u64)
47ReadRef
48Ge
49BrFalse(51)
B4:
50Branch(55)
B5:
51MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
52Pop
53LdConst[25](u64: 4028)
54Abort
B6:
55CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
56MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
57CopyLoc[14](loc8: u64)
58Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
59StLoc[10](loc4: Balance<Ty0>)
60CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
61MutBorrowFieldGeneric[2](LiquidityPool.protocol_base_fees: Balance<Ty0>)
62MoveLoc[10](loc4: Balance<Ty0>)
63Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
64Pop
65CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
66CopyLoc[12](loc6: u64)
67Call increment_reward_rps<Ty0>(&mut LiquidityPool<Ty0>, u64)
68ImmBorrowLoc[4](Arg4: Option<u64>)
69Call option::is_some<u64>(&Option<u64>): bool
70BrFalse(82)
B7:
71CopyLoc[7](loc1: u64)
72ImmBorrowLoc[4](Arg4: Option<u64>)
73Call option::borrow<u64>(&Option<u64>): &u64
74ReadRef
75Ge
76BrFalse(78)
B8:
77Branch(82)
B9:
78MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
79Pop
80LdConst[5](u64: 4007)
81Abort
B10:
82Call type_name::with_defining_ids<Ty1>(): TypeName
83Call type_name::into_string(TypeName): String
84StLoc[16](loc10: String)
85CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
86MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
87MoveLoc[16](loc10: String)
88Call dynamic_field::borrow_mut<String, QuoteAssetReserve<Ty1>>(&mut UID, String): &mut QuoteAssetReserve<Ty1>
89StLoc[19](loc13: &mut QuoteAssetReserve<Ty1>)
90MoveLoc[3](Arg3: Balance<Ty1>)
91StLoc[17](loc11: Balance<Ty1>)
92CopyLoc[19](loc13: &mut QuoteAssetReserve<Ty1>)
93MutBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
94MutBorrowLoc[17](loc11: Balance<Ty1>)
95CopyLoc[15](loc9: u64)
96Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
97Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
98Pop
99CopyLoc[11](loc5: u128)
100CopyLoc[19](loc13: &mut QuoteAssetReserve<Ty1>)
101MutBorrowFieldGeneric[31](QuoteAssetReserve.ideal_reserve_calc: u128)
102WriteRef
103MoveLoc[19](loc13: &mut QuoteAssetReserve<Ty1>)
104ImmBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
105Call balance::value<Ty1>(&Balance<Ty1>): u64
106StLoc[18](loc12: u64)
107CopyLoc[7](loc1: u64)
108CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
109ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
110Call balance::value<Ty0>(&Balance<Ty0>): u64
111Le
112BrFalse(114)
B11:
113Branch(118)
B12:
114MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
115Pop
116LdConst[0](u64: 4000)
117Abort
B13:
118CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
119MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
120CopyLoc[7](loc1: u64)
121Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
122StLoc[8](loc2: Balance<Ty0>)
123CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
124ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
125Call object::uid_to_inner(&UID): ID
126MoveLoc[20](loc14: address)
127MoveLoc[15](loc9: u64)
128MoveLoc[7](loc1: u64)
129LdTrue
130CopyLoc[9](loc3: u64)
131MoveLoc[11](loc5: u128)
132MoveLoc[22](loc16: u64)
133MoveLoc[9](loc3: u64)
134Add
135MoveLoc[21](loc15: u64)
136CastU64
137MoveLoc[12](loc6: u64)
138CastU64
139MoveLoc[14](loc8: u64)
140MoveLoc[13](loc7: u128)
141MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
142ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
143Call balance::value<Ty0>(&Balance<Ty0>): u64
144MoveLoc[18](loc12: u64)
145PackGeneric[19](SwapExecutedV2<Ty0, Ty1>)
146Call event::emit<SwapExecutedV2<Ty0, Ty1>>(SwapExecutedV2<Ty0, Ty1>)
147MoveLoc[8](loc2: Balance<Ty0>)
148MoveLoc[17](loc11: Balance<Ty1>)
149Ret
}
 
public swap_sell<Ty0, Ty1>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &Oracle, Arg2: &Clock, Arg3: Balance<Ty0>, Arg4: Option<u64>, Arg5: &mut TxContext): Balance<Ty0> * Balance<Ty1> {
L6: loc0: SwapSimulationResult
L7: loc1: u64
L8: loc2: Balance<Ty0>
L9: loc3: Balance<Ty0>
L10: loc4: u64
L11: loc5: u64
L12: loc6: Balance<Ty0>
L13: loc7: u128
L14: loc8: u64
L15: loc9: u128
L16: loc10: u64
L17: loc11: String
L18: loc12: u64
L19: loc13: Balance<Ty1>
L20: loc14: u64
L21: loc15: &mut QuoteAssetReserve<Ty1>
L22: loc16: address
L23: loc17: u64
L24: loc18: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
2ReadRef
3Not
4BrFalse(6)
B1:
5Branch(16)
B2:
6MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
7Pop
8MoveLoc[1](Arg1: &Oracle)
9Pop
10MoveLoc[5](Arg5: &mut TxContext)
11Pop
12MoveLoc[2](Arg2: &Clock)
13Pop
14LdConst[4](u64: 4005)
15Abort
B3:
16MoveLoc[5](Arg5: &mut TxContext)
17FreezeRef
18Call tx_context::sender(&TxContext): address
19StLoc[22](loc16: address)
20ImmBorrowLoc[3](Arg3: Balance<Ty0>)
21Call balance::value<Ty0>(&Balance<Ty0>): u64
22StLoc[7](loc1: u64)
23CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
24FreezeRef
25MoveLoc[1](Arg1: &Oracle)
26MoveLoc[2](Arg2: &Clock)
27CopyLoc[7](loc1: u64)
28Call simulate_sell_swap<Ty0, Ty1>(&LiquidityPool<Ty0>, &Oracle, &Clock, u64): SwapSimulationResult
29StLoc[6](loc0: SwapSimulationResult)
30ImmBorrowLoc[6](loc0: SwapSimulationResult)
31Call simulation_result_inner(&SwapSimulationResult): u64 * u64 * u64 * u64 * u128 * u64 * u64 * u64 * u128
32StLoc[15](loc9: u128)
33StLoc[16](loc10: u64)
34StLoc[14](loc8: u64)
35StLoc[23](loc17: u64)
36StLoc[13](loc7: u128)
37StLoc[11](loc5: u64)
38StLoc[24](loc18: u64)
39StLoc[18](loc12: u64)
40StLoc[10](loc4: u64)
41CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
42FreezeRef
43Call assert_quote_is_trading<Ty0, Ty1>(&LiquidityPool<Ty0>)
44MoveLoc[3](Arg3: Balance<Ty0>)
45StLoc[8](loc2: Balance<Ty0>)
46MutBorrowLoc[8](loc2: Balance<Ty0>)
47CopyLoc[16](loc10: u64)
48Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
49StLoc[12](loc6: Balance<Ty0>)
50CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
51MutBorrowFieldGeneric[2](LiquidityPool.protocol_base_fees: Balance<Ty0>)
52MoveLoc[12](loc6: Balance<Ty0>)
53Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
54Pop
55CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
56CopyLoc[14](loc8: u64)
57Call increment_reward_rps<Ty0>(&mut LiquidityPool<Ty0>, u64)
58ImmBorrowLoc[4](Arg4: Option<u64>)
59Call option::is_some<u64>(&Option<u64>): bool
60BrFalse(72)
B4:
61CopyLoc[18](loc12: u64)
62ImmBorrowLoc[4](Arg4: Option<u64>)
63Call option::borrow<u64>(&Option<u64>): &u64
64ReadRef
65Ge
66BrFalse(68)
B5:
67Branch(72)
B6:
68MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
69Pop
70LdConst[5](u64: 4007)
71Abort
B7:
72MutBorrowLoc[8](loc2: Balance<Ty0>)
73MoveLoc[10](loc4: u64)
74CopyLoc[14](loc8: u64)
75Add
76Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
77StLoc[9](loc3: Balance<Ty0>)
78CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
79MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
80MoveLoc[9](loc3: Balance<Ty0>)
81Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
82Pop
83Call type_name::with_defining_ids<Ty1>(): TypeName
84Call type_name::into_string(TypeName): String
85StLoc[17](loc11: String)
86CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
87MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
88MoveLoc[17](loc11: String)
89Call dynamic_field::borrow_mut<String, QuoteAssetReserve<Ty1>>(&mut UID, String): &mut QuoteAssetReserve<Ty1>
90StLoc[21](loc15: &mut QuoteAssetReserve<Ty1>)
91CopyLoc[18](loc12: u64)
92CopyLoc[21](loc15: &mut QuoteAssetReserve<Ty1>)
93ImmBorrowFieldGeneric[24](QuoteAssetReserve.min_out: u64)
94ReadRef
95Ge
96BrFalse(98)
B8:
97Branch(104)
B9:
98MoveLoc[21](loc15: &mut QuoteAssetReserve<Ty1>)
99Pop
100MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
101Pop
102LdConst[26](u64: 4029)
103Abort
B10:
104CopyLoc[21](loc15: &mut QuoteAssetReserve<Ty1>)
105MutBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
106CopyLoc[18](loc12: u64)
107Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
108StLoc[19](loc13: Balance<Ty1>)
109CopyLoc[13](loc7: u128)
110CopyLoc[21](loc15: &mut QuoteAssetReserve<Ty1>)
111MutBorrowFieldGeneric[31](QuoteAssetReserve.ideal_reserve_calc: u128)
112WriteRef
113MoveLoc[21](loc15: &mut QuoteAssetReserve<Ty1>)
114ImmBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
115Call balance::value<Ty1>(&Balance<Ty1>): u64
116StLoc[20](loc14: u64)
117CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
118ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
119Call object::uid_to_inner(&UID): ID
120MoveLoc[22](loc16: address)
121MoveLoc[7](loc1: u64)
122MoveLoc[18](loc12: u64)
123LdFalse
124CopyLoc[11](loc5: u64)
125MoveLoc[13](loc7: u128)
126MoveLoc[24](loc18: u64)
127MoveLoc[11](loc5: u64)
128Add
129MoveLoc[23](loc17: u64)
130MoveLoc[14](loc8: u64)
131MoveLoc[16](loc10: u64)
132MoveLoc[15](loc9: u128)
133MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
134ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
135Call balance::value<Ty0>(&Balance<Ty0>): u64
136MoveLoc[20](loc14: u64)
137PackGeneric[19](SwapExecutedV2<Ty0, Ty1>)
138Call event::emit<SwapExecutedV2<Ty0, Ty1>>(SwapExecutedV2<Ty0, Ty1>)
139MoveLoc[8](loc2: Balance<Ty0>)
140MoveLoc[19](loc13: Balance<Ty1>)
141Ret
}
 
public flash_borrow<Ty0, Ty1>(Arg0: &mut LiquidityPool<Ty0>, Arg1: &Oracle, Arg2: &Clock, Arg3: u64, Arg4: &mut TxContext): Balance<Ty1> * FlashSwapPromise<Ty0, Ty1> {
L5: loc0: u64
L6: loc1: Balance<Ty1>
L7: loc2: address
L8: loc3: ID
L9: loc4: u128
L10: loc5: FlashSwapPromise<Ty0, Ty1>
L11: loc6: u64
L12: loc7: String
L13: loc8: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
5ReadRef
6Not
7BrFalse(9)
B1:
8Branch(19)
B2:
9MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
10Pop
11MoveLoc[1](Arg1: &Oracle)
12Pop
13MoveLoc[4](Arg4: &mut TxContext)
14Pop
15MoveLoc[2](Arg2: &Clock)
16Pop
17LdConst[4](u64: 4005)
18Abort
B3:
19CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
20FreezeRef
21Call is_flash_swap_enabled<Ty0>(&LiquidityPool<Ty0>): bool
22BrFalse(24)
B4:
23Branch(34)
B5:
24MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
25Pop
26MoveLoc[1](Arg1: &Oracle)
27Pop
28MoveLoc[4](Arg4: &mut TxContext)
29Pop
30MoveLoc[2](Arg2: &Clock)
31Pop
32LdConst[22](u64: 4025)
33Abort
B6:
34CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
35FreezeRef
36Call assert_quote_is_supported<Ty0, Ty1>(&LiquidityPool<Ty0>)
37CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
38FreezeRef
39Call assert_quote_is_trading<Ty0, Ty1>(&LiquidityPool<Ty0>)
40CopyLoc[3](Arg3: u64)
41LdU64(0)
42Gt
43BrFalse(45)
B7:
44Branch(55)
B8:
45MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
46Pop
47MoveLoc[1](Arg1: &Oracle)
48Pop
49MoveLoc[4](Arg4: &mut TxContext)
50Pop
51MoveLoc[2](Arg2: &Clock)
52Pop
53LdConst[17](u64: 4020)
54Abort
B9:
55CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
56FreezeRef
57Call get_quote_balance<Ty0, Ty1>(&LiquidityPool<Ty0>): u64
58CopyLoc[3](Arg3: u64)
59Ge
60BrFalse(62)
B10:
61Branch(72)
B11:
62MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
63Pop
64MoveLoc[1](Arg1: &Oracle)
65Pop
66MoveLoc[4](Arg4: &mut TxContext)
67Pop
68MoveLoc[2](Arg2: &Clock)
69Pop
70LdConst[18](u64: 4021)
71Abort
B12:
72MoveLoc[1](Arg1: &Oracle)
73MoveLoc[2](Arg2: &Clock)
74Call get_price<Ty0, Ty1>(&Oracle, &Clock): u128 * bool
75Pop
76StLoc[9](loc4: u128)
77CopyLoc[3](Arg3: u64)
78CastU128
79LdConst[31](u128: 1000..)
80CopyLoc[9](loc4: u128)
81Call math::mul_div_u128(u128, u128, u128): u128
82CastU64
83StLoc[5](loc0: u64)
84CopyLoc[5](loc0: u64)
85LdU64(0)
86Gt
87BrFalse(89)
B13:
88Branch(95)
B14:
89MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
90Pop
91MoveLoc[4](Arg4: &mut TxContext)
92Pop
93LdConst[13](u64: 4016)
94Abort
B15:
95CopyLoc[5](loc0: u64)
96CastU128
97CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
98FreezeRef
99Call flash_swap_protocol_fee<Ty0>(&LiquidityPool<Ty0>): u64
100CastU128
101LdConst[33](u128: 10000)
102Call math::mul_div_u128(u128, u128, u128): u128
103CastU64
104StLoc[11](loc6: u64)
105MoveLoc[5](loc0: u64)
106MoveLoc[11](loc6: u64)
107Add
108StLoc[13](loc8: u64)
109CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
110ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
111Call object::uid_to_inner(&UID): ID
112StLoc[8](loc3: ID)
113MoveLoc[4](Arg4: &mut TxContext)
114FreezeRef
115Call tx_context::sender(&TxContext): address
116StLoc[7](loc2: address)
117CopyLoc[8](loc3: ID)
118CopyLoc[3](Arg3: u64)
119CopyLoc[13](loc8: u64)
120CopyLoc[9](loc4: u128)
121PackGeneric[20](FlashSwapPromise<Ty0, Ty1>)
122StLoc[10](loc5: FlashSwapPromise<Ty0, Ty1>)
123Call type_name::with_defining_ids<Ty1>(): TypeName
124Call type_name::into_string(TypeName): String
125StLoc[12](loc7: String)
126MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
127MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
128MoveLoc[12](loc7: String)
129Call dynamic_field::borrow_mut<String, QuoteAssetReserve<Ty1>>(&mut UID, String): &mut QuoteAssetReserve<Ty1>
130MutBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
131CopyLoc[3](Arg3: u64)
132Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
133StLoc[6](loc1: Balance<Ty1>)
134MoveLoc[8](loc3: ID)
135MoveLoc[7](loc2: address)
136MoveLoc[3](Arg3: u64)
137MoveLoc[13](loc8: u64)
138MoveLoc[9](loc4: u128)
139PackGeneric[21](FlashBorrowEvent<Ty0, Ty1>)
140Call event::emit<FlashBorrowEvent<Ty0, Ty1>>(FlashBorrowEvent<Ty0, Ty1>)
141MoveLoc[6](loc1: Balance<Ty1>)
142MoveLoc[10](loc5: FlashSwapPromise<Ty0, Ty1>)
143Ret
}
 
public flash_repay<Ty0, Ty1>(Arg0: &mut LiquidityPool<Ty0>, Arg1: FlashSwapPromise<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: &mut TxContext): Balance<Ty0> {
L4: loc0: u64
L5: loc1: u64
L6: loc2: address
L7: loc3: Balance<Ty0>
L8: loc4: ID
L9: loc5: u128
L10: loc6: Balance<Ty0>
L11: loc7: u64
L12: loc8: u64
L13: loc9: u64
B0:
0CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3MoveLoc[1](Arg1: FlashSwapPromise<Ty0, Ty1>)
4UnpackGeneric[20](FlashSwapPromise<Ty0, Ty1>)
5StLoc[9](loc5: u128)
6StLoc[12](loc8: u64)
7StLoc[5](loc1: u64)
8StLoc[8](loc4: ID)
9CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
10ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
11Call object::uid_to_inner(&UID): ID
12CopyLoc[8](loc4: ID)
13Eq
14BrFalse(16)
B1:
15Branch(22)
B2:
16MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
17Pop
18MoveLoc[3](Arg3: &mut TxContext)
19Pop
20LdConst[23](u64: 4026)
21Abort
B3:
22ImmBorrowLoc[2](Arg2: Balance<Ty0>)
23Call balance::value<Ty0>(&Balance<Ty0>): u64
24CopyLoc[12](loc8: u64)
25Ge
26BrFalse(28)
B4:
27Branch(34)
B5:
28MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
29Pop
30MoveLoc[3](Arg3: &mut TxContext)
31Pop
32LdConst[24](u64: 4027)
33Abort
B6:
34CopyLoc[5](loc1: u64)
35CastU128
36LdConst[31](u128: 1000..)
37CopyLoc[9](loc5: u128)
38Call math::mul_div_u128(u128, u128, u128): u128
39CastU64
40StLoc[4](loc0: u64)
41CopyLoc[12](loc8: u64)
42CopyLoc[4](loc0: u64)
43Sub
44StLoc[11](loc7: u64)
45MutBorrowLoc[2](Arg2: Balance<Ty0>)
46MoveLoc[4](loc0: u64)
47Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
48StLoc[10](loc6: Balance<Ty0>)
49MutBorrowLoc[2](Arg2: Balance<Ty0>)
50CopyLoc[11](loc7: u64)
51Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
52StLoc[7](loc3: Balance<Ty0>)
53CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
54MutBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
55MoveLoc[10](loc6: Balance<Ty0>)
56Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
57Pop
58CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
59MutBorrowFieldGeneric[2](LiquidityPool.protocol_base_fees: Balance<Ty0>)
60MoveLoc[7](loc3: Balance<Ty0>)
61Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
62Pop
63ImmBorrowLoc[2](Arg2: Balance<Ty0>)
64Call balance::value<Ty0>(&Balance<Ty0>): u64
65StLoc[13](loc9: u64)
66MoveLoc[3](Arg3: &mut TxContext)
67FreezeRef
68Call tx_context::sender(&TxContext): address
69StLoc[6](loc2: address)
70CopyLoc[8](loc4: ID)
71CopyLoc[6](loc2: address)
72CopyLoc[12](loc8: u64)
73CopyLoc[11](loc7: u64)
74MoveLoc[13](loc9: u64)
75PackGeneric[22](FlashRepayEvent<Ty0, Ty1>)
76Call event::emit<FlashRepayEvent<Ty0, Ty1>>(FlashRepayEvent<Ty0, Ty1>)
77MoveLoc[8](loc4: ID)
78MoveLoc[6](loc2: address)
79MoveLoc[12](loc8: u64)
80MoveLoc[5](loc1: u64)
81LdFalse
82LdU64(0)
83LdU128(0)
84CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
85FreezeRef
86Call flash_swap_protocol_fee<Ty0>(&LiquidityPool<Ty0>): u64
87LdU64(0)
88LdU64(0)
89MoveLoc[11](loc7: u64)
90MoveLoc[9](loc5: u128)
91CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
92ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
93Call balance::value<Ty0>(&Balance<Ty0>): u64
94MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
95FreezeRef
96Call get_quote_balance<Ty0, Ty1>(&LiquidityPool<Ty0>): u64
97PackGeneric[19](SwapExecutedV2<Ty0, Ty1>)
98Call event::emit<SwapExecutedV2<Ty0, Ty1>>(SwapExecutedV2<Ty0, Ty1>)
99MoveLoc[2](Arg2: Balance<Ty0>)
100Ret
}
 
public promise_inner<Ty0, Ty1>(Arg0: &FlashSwapPromise<Ty0, Ty1>): ID * u64 * u64 * u128 {
B0:
0CopyLoc[0](Arg0: &FlashSwapPromise<Ty0, Ty1>)
1ImmBorrowFieldGeneric[32](FlashSwapPromise.pool_id: ID)
2ReadRef
3CopyLoc[0](Arg0: &FlashSwapPromise<Ty0, Ty1>)
4ImmBorrowFieldGeneric[33](FlashSwapPromise.borrowed_amount: u64)
5ReadRef
6CopyLoc[0](Arg0: &FlashSwapPromise<Ty0, Ty1>)
7ImmBorrowFieldGeneric[34](FlashSwapPromise.repayment_amount: u64)
8ReadRef
9MoveLoc[0](Arg0: &FlashSwapPromise<Ty0, Ty1>)
10ImmBorrowFieldGeneric[35](FlashSwapPromise.price: u128)
11ReadRef
12Ret
}
 
increment_reward_rps<Ty0>(Arg0: &mut LiquidityPool<Ty0>, Arg1: u64) {
L2: loc0: String
L3: loc1: u128
B0:
0MoveLoc[1](Arg1: u64)
1CastU128
2LdConst[31](u128: 1000..)
3CastU128
4CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
5ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
6ReadRef
7CastU128
8Call math::mul_div_u128(u128, u128, u128): u128
9StLoc[3](loc1: u128)
10Call type_name::with_defining_ids<Ty0>(): TypeName
11Call type_name::into_string(TypeName): String
12StLoc[2](loc0: String)
13CopyLoc[0](Arg0: &mut LiquidityPool<Ty0>)
14ImmBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
15CopyLoc[2](loc0: String)
16Call table::borrow<String, u128>(&Table<String, u128>, String): &u128
17ReadRef
18MoveLoc[3](loc1: u128)
19Add
20MoveLoc[0](Arg0: &mut LiquidityPool<Ty0>)
21MutBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
22MoveLoc[2](loc0: String)
23Call table::borrow_mut<String, u128>(&mut Table<String, u128>, String): &mut u128
24WriteRef
25Ret
}
 
public withdraw_shares_simulation_result_inner(Arg0: &WithdrawSharesSimulationResult): u64 * u64 * u64 * u64 * u64 * u64 * u64 {
B0:
0CopyLoc[0](Arg0: &WithdrawSharesSimulationResult)
1ImmBorrowField[51](WithdrawSharesSimulationResult.shares_burn: u64)
2ReadRef
3CopyLoc[0](Arg0: &WithdrawSharesSimulationResult)
4ImmBorrowField[52](WithdrawSharesSimulationResult.base_out_gross: u64)
5ReadRef
6CopyLoc[0](Arg0: &WithdrawSharesSimulationResult)
7ImmBorrowField[45](WithdrawSharesSimulationResult.base_fee: u64)
8ReadRef
9CopyLoc[0](Arg0: &WithdrawSharesSimulationResult)
10ImmBorrowField[53](WithdrawSharesSimulationResult.total_base_fees: u64)
11ReadRef
12CopyLoc[0](Arg0: &WithdrawSharesSimulationResult)
13ImmBorrowField[43](WithdrawSharesSimulationResult.base_out: u64)
14ReadRef
15CopyLoc[0](Arg0: &WithdrawSharesSimulationResult)
16ImmBorrowField[44](WithdrawSharesSimulationResult.total_lp_shares: u64)
17ReadRef
18MoveLoc[0](Arg0: &WithdrawSharesSimulationResult)
19ImmBorrowField[54](WithdrawSharesSimulationResult.net_base_added: u64)
20ReadRef
21Ret
}
 
public simulation_result_inner(Arg0: &SwapSimulationResult): u64 * u64 * u64 * u64 * u128 * u64 * u64 * u64 * u128 {
B0:
0CopyLoc[0](Arg0: &SwapSimulationResult)
1ImmBorrowField[55](SwapSimulationResult.base_out: u64)
2ReadRef
3CopyLoc[0](Arg0: &SwapSimulationResult)
4ImmBorrowField[56](SwapSimulationResult.quote_out: u64)
5ReadRef
6CopyLoc[0](Arg0: &SwapSimulationResult)
7ImmBorrowField[57](SwapSimulationResult.swap_fee_pct: u64)
8ReadRef
9CopyLoc[0](Arg0: &SwapSimulationResult)
10ImmBorrowField[58](SwapSimulationResult.dynamic_fee_pct: u64)
11ReadRef
12CopyLoc[0](Arg0: &SwapSimulationResult)
13ImmBorrowField[59](SwapSimulationResult.ideal_quote_amt: u128)
14ReadRef
15CopyLoc[0](Arg0: &SwapSimulationResult)
16ImmBorrowField[60](SwapSimulationResult.swap_fee: u64)
17ReadRef
18CopyLoc[0](Arg0: &SwapSimulationResult)
19ImmBorrowField[61](SwapSimulationResult.lp_fee: u64)
20ReadRef
21CopyLoc[0](Arg0: &SwapSimulationResult)
22ImmBorrowField[62](SwapSimulationResult.protocol_fee: u64)
23ReadRef
24MoveLoc[0](Arg0: &SwapSimulationResult)
25ImmBorrowField[63](SwapSimulationResult.price_used: u128)
26ReadRef
27Ret
}
 
public simulate_withdraw_shares<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: &LPPosition<Ty0>, Arg2: u64): WithdrawSharesSimulationResult {
L3: loc0: u64
L4: loc1: u64
L5: loc2: u64
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
2CopyLoc[1](Arg1: &LPPosition<Ty0>)
3ImmBorrowFieldGeneric[26](LPPosition.pool_id: ID)
4ReadRef
5CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
6ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
7Call object::uid_to_inner(&UID): ID
8Eq
9BrFalse(11)
B1:
10Branch(17)
B2:
11MoveLoc[1](Arg1: &LPPosition<Ty0>)
12Pop
13MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
14Pop
15LdConst[10](u64: 4012)
16Abort
B3:
17MoveLoc[1](Arg1: &LPPosition<Ty0>)
18ImmBorrowFieldGeneric[27](LPPosition.shares: u64)
19ReadRef
20CopyLoc[2](Arg2: u64)
21Ge
22BrFalse(24)
B4:
23Branch(28)
B5:
24MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
25Pop
26LdConst[30](u64: 4033)
27Abort
B6:
28CopyLoc[2](Arg2: u64)
29LdConst[34](u64: 1000)
30Div
31StLoc[4](loc1: u64)
32CopyLoc[4](loc1: u64)
33CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
34ImmBorrowFieldGeneric[7](LiquidityPool.lp_withdrawal_fee_pct: u64)
35ReadRef
36Call calculate_net_and_fee_amount(u64, u64): u64 * u64
37StLoc[5](loc2: u64)
38StLoc[3](loc0: u64)
39CopyLoc[3](loc0: u64)
40CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
41ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
42Call balance::value<Ty0>(&Balance<Ty0>): u64
43Le
44BrFalse(46)
B7:
45Branch(50)
B8:
46MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
47Pop
48LdConst[0](u64: 4000)
49Abort
B9:
50CopyLoc[2](Arg2: u64)
51CopyLoc[4](loc1: u64)
52CopyLoc[5](loc2: u64)
53CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
54ImmBorrowFieldGeneric[2](LiquidityPool.protocol_base_fees: Balance<Ty0>)
55Call balance::value<Ty0>(&Balance<Ty0>): u64
56MoveLoc[5](loc2: u64)
57Add
58MoveLoc[3](loc0: u64)
59CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
60ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
61ReadRef
62MoveLoc[2](Arg2: u64)
63Sub
64MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
65Call net_base_added<Ty0>(&LiquidityPool<Ty0>): u64
66MoveLoc[4](loc1: u64)
67Sub
68Pack[39](WithdrawSharesSimulationResult)
69Ret
}
 
public simulate_swap<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>, Arg1: &Oracle, Arg2: &Clock, Arg3: u64, Arg4: bool): SwapSimulationResult {
L5: loc0: SwapSimulationResult
B0:
0MoveLoc[4](Arg4: bool)
1BrFalse(9)
B1:
2MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
3MoveLoc[1](Arg1: &Oracle)
4MoveLoc[2](Arg2: &Clock)
5MoveLoc[3](Arg3: u64)
6Call simulate_buy_swap<Ty0, Ty1>(&LiquidityPool<Ty0>, &Oracle, &Clock, u64): SwapSimulationResult
7StLoc[5](loc0: SwapSimulationResult)
8Branch(15)
B2:
9MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
10MoveLoc[1](Arg1: &Oracle)
11MoveLoc[2](Arg2: &Clock)
12MoveLoc[3](Arg3: u64)
13Call simulate_sell_swap<Ty0, Ty1>(&LiquidityPool<Ty0>, &Oracle, &Clock, u64): SwapSimulationResult
14StLoc[5](loc0: SwapSimulationResult)
B3:
15MoveLoc[5](loc0: SwapSimulationResult)
16Ret
}
 
assert_quote_is_supported<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>) {
L1: loc0: String
B0:
0Call type_name::with_defining_ids<Ty1>(): TypeName
1Call type_name::into_string(TypeName): String
2StLoc[1](loc0: String)
3CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
5ImmBorrowLoc[1](loc0: String)
6Call vector::contains<String>(&vector<String>, &String): bool
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
10Pop
11LdConst[3](u64: 4003)
12Abort
B3:
13MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
14ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
15MoveLoc[1](loc0: String)
16Call dynamic_field::exists_<String>(&UID, String): bool
17BrFalse(19)
B4:
18Branch(21)
B5:
19LdConst[3](u64: 4003)
20Abort
B6:
21Ret
}
 
public simulate_buy_swap<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>, Arg1: &Oracle, Arg2: &Clock, Arg3: u64): SwapSimulationResult {
L4: loc0: u64
L5: loc1: u128
L6: loc2: u64
L7: loc3: u128
L8: loc4: u64
L9: loc5: u128
L10: loc6: u64
L11: loc7: u64
L12: loc8: u64
L13: loc9: u128
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
2CopyLoc[3](Arg3: u64)
3LdU64(0)
4Gt
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
8Pop
9MoveLoc[1](Arg1: &Oracle)
10Pop
11MoveLoc[2](Arg2: &Clock)
12Pop
13LdConst[27](u64: 4030)
14Abort
B3:
15CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
16Call assert_quote_is_supported<Ty0, Ty1>(&LiquidityPool<Ty0>)
17MoveLoc[1](Arg1: &Oracle)
18MoveLoc[2](Arg2: &Clock)
19Call get_price<Ty0, Ty1>(&Oracle, &Clock): u128 * bool
20Pop
21StLoc[9](loc5: u128)
22CopyLoc[3](Arg3: u64)
23CastU128
24LdConst[31](u128: 1000..)
25CopyLoc[9](loc5: u128)
26Call math::mul_div_u128(u128, u128, u128): u128
27StLoc[5](loc1: u128)
28CopyLoc[5](loc1: u128)
29LdU128(0)
30Neq
31BrFalse(33)
B4:
32Branch(37)
B5:
33MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
34Pop
35LdConst[13](u64: 4016)
36Abort
B6:
37CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
38CopyLoc[3](Arg3: u64)
39CopyLoc[9](loc5: u128)
40LdFalse
41Call calc_dynamic_fee<Ty0, Ty1>(&LiquidityPool<Ty0>, u64, u128, bool): u64 * u128 * u64 * u64
42StLoc[12](loc8: u64)
43StLoc[11](loc7: u64)
44StLoc[7](loc3: u128)
45StLoc[6](loc2: u64)
46MoveLoc[11](loc7: u64)
47MoveLoc[3](Arg3: u64)
48Add
49MoveLoc[12](loc8: u64)
50Le
51BrFalse(53)
B7:
52Branch(57)
B8:
53MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
54Pop
55LdConst[7](u64: 4009)
56Abort
B9:
57CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
58MoveLoc[5](loc1: u128)
59CastU64
60CopyLoc[6](loc2: u64)
61Call calculate_swap_fees<Ty0>(&LiquidityPool<Ty0>, u64, u64): u64 * u64 * u64
62StLoc[8](loc4: u64)
63StLoc[10](loc6: u64)
64StLoc[4](loc0: u64)
65CopyLoc[4](loc0: u64)
66CastU128
67CopyLoc[9](loc5: u128)
68LdConst[31](u128: 1000..)
69Call math::mul_div_u128(u128, u128, u128): u128
70StLoc[13](loc9: u128)
71MoveLoc[4](loc0: u64)
72CastU64
73MoveLoc[13](loc9: u128)
74CastU64
75MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
76ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
77ReadRef
78LdConst[34](u64: 1000)
79Mul
80MoveLoc[6](loc2: u64)
81MoveLoc[7](loc3: u128)
82CopyLoc[8](loc4: u64)
83CopyLoc[10](loc6: u64)
84Add
85CastU64
86MoveLoc[8](loc4: u64)
87CastU64
88MoveLoc[10](loc6: u64)
89CastU64
90MoveLoc[9](loc5: u128)
91Pack[40](SwapSimulationResult)
92Ret
}
 
public simulate_sell_swap<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>, Arg1: &Oracle, Arg2: &Clock, Arg3: u64): SwapSimulationResult {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u128
L7: loc3: u64
L8: loc4: u128
L9: loc5: u64
L10: loc6: u64
L11: loc7: u128
L12: loc8: u128
L13: loc9: u128
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
2CopyLoc[3](Arg3: u64)
3LdU64(0)
4Gt
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
8Pop
9MoveLoc[1](Arg1: &Oracle)
10Pop
11MoveLoc[2](Arg2: &Clock)
12Pop
13LdConst[28](u64: 4031)
14Abort
B3:
15CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
16Call assert_quote_is_supported<Ty0, Ty1>(&LiquidityPool<Ty0>)
17MoveLoc[1](Arg1: &Oracle)
18MoveLoc[2](Arg2: &Clock)
19Call get_price<Ty1, Ty0>(&Oracle, &Clock): u128 * bool
20Pop
21StLoc[8](loc4: u128)
22CopyLoc[3](Arg3: u64)
23CastU128
24LdConst[31](u128: 1000..)
25CopyLoc[8](loc4: u128)
26Call math::mul_div_u128(u128, u128, u128): u128
27StLoc[12](loc8: u128)
28LdConst[31](u128: 1000..)
29LdConst[31](u128: 1000..)
30Mul
31CopyLoc[8](loc4: u128)
32Div
33StLoc[13](loc9: u128)
34CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
35MoveLoc[12](loc8: u128)
36CastU64
37MoveLoc[13](loc9: u128)
38LdTrue
39Call calc_dynamic_fee<Ty0, Ty1>(&LiquidityPool<Ty0>, u64, u128, bool): u64 * u128 * u64 * u64
40Pop
41StLoc[10](loc6: u64)
42StLoc[6](loc2: u128)
43StLoc[5](loc1: u64)
44CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
45MoveLoc[3](Arg3: u64)
46CopyLoc[5](loc1: u64)
47Call calculate_swap_fees<Ty0>(&LiquidityPool<Ty0>, u64, u64): u64 * u64 * u64
48StLoc[7](loc3: u64)
49StLoc[9](loc5: u64)
50StLoc[4](loc0: u64)
51CopyLoc[4](loc0: u64)
52CastU128
53LdConst[31](u128: 1000..)
54CopyLoc[8](loc4: u128)
55Call math::mul_div_u128(u128, u128, u128): u128
56StLoc[11](loc7: u128)
57MoveLoc[10](loc6: u64)
58CopyLoc[11](loc7: u128)
59CastU64
60Ge
61BrFalse(63)
B4:
62Branch(67)
B5:
63MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
64Pop
65LdConst[18](u64: 4021)
66Abort
B6:
67MoveLoc[4](loc0: u64)
68CastU64
69MoveLoc[11](loc7: u128)
70CastU64
71MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
72ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
73ReadRef
74LdConst[34](u64: 1000)
75Mul
76MoveLoc[5](loc1: u64)
77MoveLoc[6](loc2: u128)
78CopyLoc[7](loc3: u64)
79CopyLoc[9](loc5: u64)
80Add
81CastU64
82MoveLoc[7](loc3: u64)
83CastU64
84MoveLoc[9](loc5: u64)
85CastU64
86MoveLoc[8](loc4: u128)
87Pack[40](SwapSimulationResult)
88Ret
}
 
public simulate_sell_swap_reverse<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>, Arg1: &Oracle, Arg2: &Clock, Arg3: u64): SwapSimulationResult {
L4: loc0: bool
L5: loc1: u64
L6: loc2: u128
L7: loc3: u64
L8: loc4: u64
L9: loc5: u64
L10: loc6: u128
L11: loc7: u64
L12: loc8: u64
L13: loc9: u64
L14: loc10: u128
L15: loc11: SwapSimulationResult
L16: loc12: u64
L17: loc13: u64
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
2CopyLoc[3](Arg3: u64)
3LdU64(0)
4Gt
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
8Pop
9MoveLoc[1](Arg1: &Oracle)
10Pop
11MoveLoc[2](Arg2: &Clock)
12Pop
13LdConst[17](u64: 4020)
14Abort
B3:
15CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
16Call assert_quote_is_supported<Ty0, Ty1>(&LiquidityPool<Ty0>)
17CopyLoc[1](Arg1: &Oracle)
18CopyLoc[2](Arg2: &Clock)
19Call get_price<Ty1, Ty0>(&Oracle, &Clock): u128 * bool
20Pop
21StLoc[10](loc6: u128)
22LdConst[31](u128: 1000..)
23LdConst[31](u128: 1000..)
24Mul
25CopyLoc[10](loc6: u128)
26Div
27StLoc[14](loc10: u128)
28CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
29CopyLoc[3](Arg3: u64)
30MoveLoc[14](loc10: u128)
31LdTrue
32Call calc_dynamic_fee<Ty0, Ty1>(&LiquidityPool<Ty0>, u64, u128, bool): u64 * u128 * u64 * u64
33Pop
34Pop
35Pop
36StLoc[8](loc4: u64)
37CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
38ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
39ReadRef
40LdConst[34](u64: 1000)
41Mul
42CastU64
43StLoc[16](loc12: u64)
44CopyLoc[8](loc4: u64)
45MoveLoc[16](loc12: u64)
46Add
47StLoc[17](loc13: u64)
48CopyLoc[3](Arg3: u64)
49CastU128
50CopyLoc[10](loc6: u128)
51LdConst[31](u128: 1000..)
52Call math::mul_div_u128(u128, u128, u128): u128
53CastU64
54StLoc[7](loc3: u64)
55CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
56CopyLoc[7](loc3: u64)
57MoveLoc[8](loc4: u64)
58Call calculate_fees<Ty0>(&LiquidityPool<Ty0>, u64, u64): u64 * u64
59StLoc[11](loc7: u64)
60StLoc[9](loc5: u64)
61LdConst[32](u64: 10000)
62LdConst[34](u64: 1000)
63Mul
64CastU128
65StLoc[6](loc2: u128)
66MoveLoc[7](loc3: u64)
67CastU128
68CopyLoc[6](loc2: u128)
69MoveLoc[6](loc2: u128)
70MoveLoc[17](loc13: u64)
71CastU128
72Sub
73Call math::mul_div_u128(u128, u128, u128): u128
74CastU64
75StLoc[5](loc1: u64)
76CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
77Call get_quote_balance<Ty0, Ty1>(&LiquidityPool<Ty0>): u64
78StLoc[12](loc8: u64)
79CopyLoc[3](Arg3: u64)
80CopyLoc[12](loc8: u64)
81Le
82BrFalse(84)
B4:
83Branch(92)
B5:
84MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
85Pop
86MoveLoc[1](Arg1: &Oracle)
87Pop
88MoveLoc[2](Arg2: &Clock)
89Pop
90LdConst[18](u64: 4021)
91Abort
B6:
92MoveLoc[12](loc8: u64)
93CastU128
94MoveLoc[10](loc6: u128)
95LdConst[31](u128: 1000..)
96Call math::mul_div_u128(u128, u128, u128): u128
97CastU64
98StLoc[13](loc9: u64)
99MoveLoc[5](loc1: u64)
100CopyLoc[13](loc9: u64)
101Call u64::min(u64, u64): u64
102MoveLoc[9](loc5: u64)
103MoveLoc[11](loc7: u64)
104Add
105CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
106ImmBorrowFieldGeneric[11](LiquidityPool.min_base_out: u64)
107ReadRef
108Add
109Call u64::max(u64, u64): u64
110StLoc[5](loc1: u64)
111CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
112CopyLoc[1](Arg1: &Oracle)
113CopyLoc[2](Arg2: &Clock)
114CopyLoc[5](loc1: u64)
115Call simulate_sell_swap<Ty0, Ty1>(&LiquidityPool<Ty0>, &Oracle, &Clock, u64): SwapSimulationResult
116StLoc[15](loc11: SwapSimulationResult)
117ImmBorrowLoc[15](loc11: SwapSimulationResult)
118ImmBorrowField[56](SwapSimulationResult.quote_out: u64)
119ReadRef
120MoveLoc[3](Arg3: u64)
121Lt
122BrFalse(128)
B7:
123CopyLoc[5](loc1: u64)
124MoveLoc[13](loc9: u64)
125Lt
126StLoc[4](loc0: bool)
127Branch(130)
B8:
128LdFalse
129StLoc[4](loc0: bool)
B9:
130MoveLoc[4](loc0: bool)
131BrFalse(141)
B10:
132MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
133MoveLoc[1](Arg1: &Oracle)
134MoveLoc[2](Arg2: &Clock)
135MoveLoc[5](loc1: u64)
136LdU64(1)
137Add
138Call simulate_sell_swap<Ty0, Ty1>(&LiquidityPool<Ty0>, &Oracle, &Clock, u64): SwapSimulationResult
139StLoc[15](loc11: SwapSimulationResult)
140Branch(147)
B11:
141MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
142Pop
143MoveLoc[1](Arg1: &Oracle)
144Pop
145MoveLoc[2](Arg2: &Clock)
146Pop
B12:
147MoveLoc[15](loc11: SwapSimulationResult)
148Ret
}
 
get_pool_ideal_base_anchor<Ty0>(Arg0: &LiquidityPool<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
2LdFalse
3Pack[34](IdealBaseAnchorKey)
4Call dynamic_field::borrow<IdealBaseAnchorKey, u64>(&UID, IdealBaseAnchorKey): &u64
5ReadRef
6Ret
}
 
get_pool_liquidity_for_fee_calculation<Ty0>(Arg0: &LiquidityPool<Ty0>): u64 * u64 {
L1: loc0: u64
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
2Call balance::value<Ty0>(&Balance<Ty0>): u64
3StLoc[1](loc0: u64)
4MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
5Call get_pool_ideal_base_anchor<Ty0>(&LiquidityPool<Ty0>): u64
6MoveLoc[1](loc0: u64)
7Ret
}
 
calculate_swap_fees<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: u64, Arg2: u64): u64 * u64 * u64 {
L3: loc0: u64
L4: loc1: u64
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1CopyLoc[1](Arg1: u64)
2MoveLoc[2](Arg2: u64)
3Call calculate_fees<Ty0>(&LiquidityPool<Ty0>, u64, u64): u64 * u64
4StLoc[4](loc1: u64)
5StLoc[3](loc0: u64)
6MoveLoc[1](Arg1: u64)
7CopyLoc[3](loc0: u64)
8Sub
9CopyLoc[4](loc1: u64)
10Sub
11MoveLoc[4](loc1: u64)
12MoveLoc[3](loc0: u64)
13Ret
}
 
calculate_fees<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: u64, Arg2: u64): u64 * u64 {
L3: loc0: u64
L4: loc1: u128
L5: loc2: u64
L6: loc3: u64
L7: loc4: u64
L8: loc5: u64
L9: loc6: u64
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
2ReadRef
3LdConst[34](u64: 1000)
4Mul
5CastU64
6StLoc[7](loc4: u64)
7MoveLoc[2](Arg2: u64)
8MoveLoc[7](loc4: u64)
9Add
10StLoc[9](loc6: u64)
11LdConst[32](u64: 10000)
12LdConst[34](u64: 1000)
13Mul
14CastU128
15StLoc[4](loc1: u128)
16CopyLoc[1](Arg1: u64)
17CastU128
18CopyLoc[4](loc1: u128)
19MoveLoc[9](loc6: u64)
20CastU128
21Sub
22MoveLoc[4](loc1: u128)
23Call math::mul_div_u128(u128, u128, u128): u128
24CastU64
25StLoc[3](loc0: u64)
26MoveLoc[1](Arg1: u64)
27MoveLoc[3](loc0: u64)
28Sub
29StLoc[8](loc5: u64)
30CopyLoc[8](loc5: u64)
31CastU128
32MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
33ImmBorrowFieldGeneric[8](LiquidityPool.lp_fee_pct: u64)
34ReadRef
35CastU128
36LdConst[33](u128: 10000)
37Call math::mul_div_u128(u128, u128, u128): u128
38LdU128(1)
39Call u128::max(u128, u128): u128
40CastU64
41StLoc[5](loc2: u64)
42MoveLoc[8](loc5: u64)
43CopyLoc[5](loc2: u64)
44Sub
45LdU64(1)
46Call u64::max(u64, u64): u64
47CastU64
48StLoc[6](loc3: u64)
49MoveLoc[5](loc2: u64)
50MoveLoc[6](loc3: u64)
51Ret
}
 
public update_net_base_fee_multiplier<Ty0>(Arg0: &ProtocolAdminCap, Arg1: &mut LiquidityPool<Ty0>, Arg2: u64, Arg3: &mut TxContext) {
B0:
0LdConst[19](u64: 4022)
1Abort
}
 
public update_ideal_base_anchor<Ty0>(Arg0: &ProtocolAdminCap, Arg1: &mut LiquidityPool<Ty0>, Arg2: u64, Arg3: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
5LdFalse
6Pack[34](IdealBaseAnchorKey)
7Call dynamic_field::exists_<IdealBaseAnchorKey>(&UID, IdealBaseAnchorKey): bool
8BrFalse(17)
B1:
9CopyLoc[2](Arg2: u64)
10CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
11MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
12LdFalse
13Pack[34](IdealBaseAnchorKey)
14Call dynamic_field::borrow_mut<IdealBaseAnchorKey, u64>(&mut UID, IdealBaseAnchorKey): &mut u64
15WriteRef
16Branch(23)
B2:
17CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
18MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
19LdFalse
20Pack[34](IdealBaseAnchorKey)
21CopyLoc[2](Arg2: u64)
22Call dynamic_field::add<IdealBaseAnchorKey, u64>(&mut UID, IdealBaseAnchorKey, u64)
B3:
23MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
24ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
25Call object::uid_to_inner(&UID): ID
26MoveLoc[2](Arg2: u64)
27Pack[35](IdealBaseAnchorUpdated)
28Call event::emit<IdealBaseAnchorUpdated>(IdealBaseAnchorUpdated)
29Ret
}
 
net_base_added<Ty0>(Arg0: &LiquidityPool<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
2ReadRef
3LdConst[34](u64: 1000)
4Div
5Ret
}
 
calculate_net_and_fee_amount(Arg0: u64, Arg1: u64): u64 * u64 {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: u64)
1CastU128
2LdConst[32](u64: 10000)
3MoveLoc[1](Arg1: u64)
4Sub
5CastU128
6LdConst[32](u64: 10000)
7CastU128
8Call math::mul_div_u128(u128, u128, u128): u128
9CastU64
10StLoc[2](loc0: u64)
11CopyLoc[2](loc0: u64)
12MoveLoc[0](Arg0: u64)
13MoveLoc[2](loc0: u64)
14Sub
15Ret
}
 
public get_price<Ty0, Ty1>(Arg0: &Oracle, Arg1: &Clock): u128 * bool {
L2: loc0: Price<Ty0, Ty1>
L3: loc1: bool
L4: loc2: PriceData
B0:
0MoveLoc[0](Arg0: &Oracle)
1MoveLoc[1](Arg1: &Clock)
2Call price_oracle::get_valid_price<Ty0, Ty1>(&Oracle, &Clock): PriceData * bool
3StLoc[3](loc1: bool)
4StLoc[4](loc2: PriceData)
5ImmBorrowLoc[4](loc2: PriceData)
6Call price_oracle::price_data_price<Ty0, Ty1>(&PriceData): Price<Ty0, Ty1>
7StLoc[2](loc0: Price<Ty0, Ty1>)
8ImmBorrowLoc[2](loc0: Price<Ty0, Ty1>)
9Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
10MoveLoc[3](loc1: bool)
11Ret
}
 
quote_limit<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>, Arg1: u128, Arg2: &QuoteAssetReserve<Ty1>): u64 {
L3: loc0: u128
L4: loc1: u64
L5: loc2: u64
L6: loc3: u64
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1Call get_pool_ideal_base_anchor<Ty0>(&LiquidityPool<Ty0>): u64
2StLoc[4](loc1: u64)
3CopyLoc[2](Arg2: &QuoteAssetReserve<Ty1>)
4ImmBorrowFieldGeneric[22](QuoteAssetReserve.limit_ratio: Option<u64>)
5MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
6ImmBorrowFieldGeneric[10](LiquidityPool.limit_ratio: u64)
7ReadRef
8Call option::get_with_default<u64>(&Option<u64>, u64): u64
9StLoc[6](loc3: u64)
10MoveLoc[4](loc1: u64)
11CastU128
12MoveLoc[1](Arg1: u128)
13LdConst[31](u128: 1000..)
14Call math::mul_div_u128(u128, u128, u128): u128
15CastU128
16MoveLoc[6](loc3: u64)
17CastU128
18LdConst[33](u128: 10000)
19Call math::mul_div_u128(u128, u128, u128): u128
20StLoc[3](loc0: u128)
21MoveLoc[2](Arg2: &QuoteAssetReserve<Ty1>)
22ImmBorrowFieldGeneric[23](QuoteAssetReserve.limit_fixed: Option<u64>)
23LdU64(18446744073709551615)
24Call option::get_with_default<u64>(&Option<u64>, u64): u64
25StLoc[5](loc2: u64)
26MoveLoc[3](loc0: u128)
27CastU64
28MoveLoc[5](loc2: u64)
29Call u64::min(u64, u64): u64
30Ret
}
 
calc_dynamic_fee<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>, Arg1: u64, Arg2: u128, Arg3: bool): u64 * u128 * u64 * u64 {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
L8: loc4: u64
L9: loc5: u128
L10: loc6: u128
L11: loc7: u64
L12: loc8: u64
L13: loc9: u128
L14: loc10: u128
L15: loc11: String
L16: loc12: u64
L17: loc13: u64
L18: loc14: &QuoteAssetReserve<Ty1>
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1Call get_pool_liquidity_for_fee_calculation<Ty0>(&LiquidityPool<Ty0>): u64 * u64
2Pop
3CastU128
4CopyLoc[2](Arg2: u128)
5LdConst[31](u128: 1000..)
6Call math::mul_div_u128(u128, u128, u128): u128
7StLoc[9](loc5: u128)
8Call type_name::with_defining_ids<Ty1>(): TypeName
9Call type_name::into_string(TypeName): String
10StLoc[15](loc11: String)
11CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
12ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
13MoveLoc[15](loc11: String)
14Call dynamic_field::borrow<String, QuoteAssetReserve<Ty1>>(&UID, String): &QuoteAssetReserve<Ty1>
15StLoc[18](loc14: &QuoteAssetReserve<Ty1>)
16CopyLoc[9](loc5: u128)
17CopyLoc[18](loc14: &QuoteAssetReserve<Ty1>)
18ImmBorrowFieldGeneric[18](QuoteAssetReserve.ideal_reserve_pct: u64)
19ReadRef
20CastU128
21LdConst[33](u128: 10000)
22Call math::mul_div_u128(u128, u128, u128): u128
23StLoc[13](loc9: u128)
24MoveLoc[9](loc5: u128)
25CopyLoc[18](loc14: &QuoteAssetReserve<Ty1>)
26ImmBorrowFieldGeneric[19](QuoteAssetReserve.max_reserve_pct: u64)
27ReadRef
28CastU128
29LdConst[33](u128: 10000)
30Call math::mul_div_u128(u128, u128, u128): u128
31StLoc[14](loc10: u128)
32CopyLoc[18](loc14: &QuoteAssetReserve<Ty1>)
33ImmBorrowFieldGeneric[20](QuoteAssetReserve.fee_base: u64)
34ReadRef
35StLoc[11](loc7: u64)
36CopyLoc[18](loc14: &QuoteAssetReserve<Ty1>)
37ImmBorrowFieldGeneric[21](QuoteAssetReserve.fee_max: u64)
38ReadRef
39StLoc[12](loc8: u64)
40CopyLoc[18](loc14: &QuoteAssetReserve<Ty1>)
41ImmBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
42Call balance::value<Ty1>(&Balance<Ty1>): u64
43StLoc[16](loc12: u64)
44MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
45MoveLoc[2](Arg2: u128)
46MoveLoc[18](loc14: &QuoteAssetReserve<Ty1>)
47Call quote_limit<Ty0, Ty1>(&LiquidityPool<Ty0>, u128, &QuoteAssetReserve<Ty1>): u64
48StLoc[17](loc13: u64)
49MoveLoc[3](Arg3: bool)
50BrFalse(65)
B1:
51CopyLoc[16](loc12: u64)
52CopyLoc[1](Arg1: u64)
53Ge
54BrFalse(60)
B2:
55CopyLoc[16](loc12: u64)
56MoveLoc[1](Arg1: u64)
57Sub
58StLoc[4](loc0: u64)
59Branch(62)
B3:
60LdU64(0)
61StLoc[4](loc0: u64)
B4:
62MoveLoc[4](loc0: u64)
63StLoc[5](loc1: u64)
64Branch(69)
B5:
65CopyLoc[16](loc12: u64)
66MoveLoc[1](Arg1: u64)
67Add
68StLoc[5](loc1: u64)
B6:
69MoveLoc[5](loc1: u64)
70CastU128
71StLoc[10](loc6: u128)
72CopyLoc[13](loc9: u128)
73LdU128(0)
74Eq
75BrFalse(79)
B7:
76LdU64(0)
77StLoc[8](loc4: u64)
78Branch(119)
B8:
79CopyLoc[10](loc6: u128)
80CopyLoc[13](loc9: u128)
81Le
82BrFalse(93)
B9:
83MoveLoc[11](loc7: u64)
84LdConst[34](u64: 1000)
85Mul
86CastU128
87MoveLoc[10](loc6: u128)
88CopyLoc[13](loc9: u128)
89Call math::mul_div_u128(u128, u128, u128): u128
90CastU64
91StLoc[7](loc3: u64)
92Branch(117)
B10:
93CopyLoc[14](loc10: u128)
94LdU128(0)
95Eq
96BrFalse(102)
B11:
97MoveLoc[11](loc7: u64)
98LdConst[34](u64: 1000)
99Mul
100StLoc[6](loc2: u64)
101Branch(115)
B12:
102MoveLoc[11](loc7: u64)
103LdConst[34](u64: 1000)
104Mul
105MoveLoc[12](loc8: u64)
106LdConst[34](u64: 1000)
107Mul
108CastU128
109MoveLoc[10](loc6: u128)
110MoveLoc[14](loc10: u128)
111Call math::mul_div_u128(u128, u128, u128): u128
112CastU64
113Add
114StLoc[6](loc2: u64)
B13:
115MoveLoc[6](loc2: u64)
116StLoc[7](loc3: u64)
B14:
117MoveLoc[7](loc3: u64)
118StLoc[8](loc4: u64)
B15:
119MoveLoc[8](loc4: u64)
120MoveLoc[13](loc9: u128)
121MoveLoc[16](loc12: u64)
122MoveLoc[17](loc13: u64)
123Ret
}
 
assert_global_config(Arg0: &GlobalConfig, Arg1: Option<u64>, Arg2: Option<u64>, Arg3: Option<u64>, Arg4: Option<u64>) {
L5: loc0: u64
L6: loc1: u64
L7: loc2: u64
L8: loc3: u64
B0:
0ImmBorrowLoc[1](Arg1: Option<u64>)
1CopyLoc[0](Arg0: &GlobalConfig)
2ImmBorrowField[4](GlobalConfig.max_swap_fee_pct: u64)
3ReadRef
4Call option::get_with_default<u64>(&Option<u64>, u64): u64
5StLoc[8](loc3: u64)
6ImmBorrowLoc[2](Arg2: Option<u64>)
7CopyLoc[0](Arg0: &GlobalConfig)
8ImmBorrowField[5](GlobalConfig.max_lp_withdrawal_fee_pct: u64)
9ReadRef
10Call option::get_with_default<u64>(&Option<u64>, u64): u64
11StLoc[7](loc2: u64)
12ImmBorrowLoc[3](Arg3: Option<u64>)
13CopyLoc[0](Arg0: &GlobalConfig)
14ImmBorrowField[6](GlobalConfig.max_lp_fee_share: u64)
15ReadRef
16Call option::get_with_default<u64>(&Option<u64>, u64): u64
17StLoc[6](loc1: u64)
18ImmBorrowLoc[4](Arg4: Option<u64>)
19MoveLoc[0](Arg0: &GlobalConfig)
20ImmBorrowField[7](GlobalConfig.max_dynamic_fee: u64)
21ReadRef
22Call option::get_with_default<u64>(&Option<u64>, u64): u64
23StLoc[5](loc0: u64)
24MoveLoc[8](loc3: u64)
25MoveLoc[5](loc0: u64)
26Add
27LdConst[32](u64: 10000)
28Le
29BrFalse(31)
B1:
30Branch(33)
B2:
31LdConst[8](u64: 4010)
32Abort
B3:
33MoveLoc[7](loc2: u64)
34LdConst[32](u64: 10000)
35Le
36BrFalse(38)
B4:
37Branch(40)
B5:
38LdConst[8](u64: 4010)
39Abort
B6:
40MoveLoc[6](loc1: u64)
41LdConst[35](u64: 9000)
42Le
43BrFalse(45)
B7:
44Branch(47)
B8:
45LdConst[8](u64: 4010)
46Abort
B9:
47Ret
}
 
assert_pool_fees(Arg0: &GlobalConfig, Arg1: Option<u64>, Arg2: Option<u64>, Arg3: Option<u64>, Arg4: Option<u64>, Arg5: Option<u64>) {
L6: loc0: u64
L7: loc1: u64
L8: loc2: u64
L9: loc3: u64
L10: loc4: u64
B0:
0ImmBorrowLoc[1](Arg1: Option<u64>)
1LdU64(0)
2Call option::get_with_default<u64>(&Option<u64>, u64): u64
3StLoc[10](loc4: u64)
4ImmBorrowLoc[2](Arg2: Option<u64>)
5LdU64(0)
6Call option::get_with_default<u64>(&Option<u64>, u64): u64
7StLoc[8](loc2: u64)
8ImmBorrowLoc[3](Arg3: Option<u64>)
9LdU64(0)
10Call option::get_with_default<u64>(&Option<u64>, u64): u64
11StLoc[7](loc1: u64)
12ImmBorrowLoc[4](Arg4: Option<u64>)
13LdU64(0)
14Call option::get_with_default<u64>(&Option<u64>, u64): u64
15StLoc[9](loc3: u64)
16ImmBorrowLoc[5](Arg5: Option<u64>)
17LdU64(0)
18Call option::get_with_default<u64>(&Option<u64>, u64): u64
19StLoc[6](loc0: u64)
20MoveLoc[10](loc4: u64)
21CopyLoc[0](Arg0: &GlobalConfig)
22ImmBorrowField[4](GlobalConfig.max_swap_fee_pct: u64)
23ReadRef
24Le
25BrFalse(27)
B1:
26Branch(31)
B2:
27MoveLoc[0](Arg0: &GlobalConfig)
28Pop
29LdConst[8](u64: 4010)
30Abort
B3:
31MoveLoc[8](loc2: u64)
32CopyLoc[0](Arg0: &GlobalConfig)
33ImmBorrowField[5](GlobalConfig.max_lp_withdrawal_fee_pct: u64)
34ReadRef
35Le
36BrFalse(38)
B4:
37Branch(42)
B5:
38MoveLoc[0](Arg0: &GlobalConfig)
39Pop
40LdConst[8](u64: 4010)
41Abort
B6:
42MoveLoc[7](loc1: u64)
43CopyLoc[0](Arg0: &GlobalConfig)
44ImmBorrowField[6](GlobalConfig.max_lp_fee_share: u64)
45ReadRef
46Le
47BrFalse(49)
B7:
48Branch(53)
B8:
49MoveLoc[0](Arg0: &GlobalConfig)
50Pop
51LdConst[8](u64: 4010)
52Abort
B9:
53MoveLoc[9](loc3: u64)
54MoveLoc[0](Arg0: &GlobalConfig)
55ImmBorrowField[7](GlobalConfig.max_dynamic_fee: u64)
56ReadRef
57Le
58BrFalse(60)
B10:
59Branch(62)
B11:
60LdConst[8](u64: 4010)
61Abort
B12:
62MoveLoc[6](loc0: u64)
63LdConst[32](u64: 10000)
64Le
65BrFalse(67)
B13:
66Branch(69)
B14:
67LdConst[8](u64: 4010)
68Abort
B15:
69Ret
}
 
assert_quote_is_trading<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>) {
L1: loc0: String
B0:
0Call type_name::with_defining_ids<Ty1>(): TypeName
1Call type_name::into_string(TypeName): String
2StLoc[1](loc0: String)
3MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
5MoveLoc[1](loc0: String)
6Call dynamic_field::borrow<String, QuoteAssetReserve<Ty1>>(&UID, String): &QuoteAssetReserve<Ty1>
7ImmBorrowFieldGeneric[25](QuoteAssetReserve.is_trading: bool)
8ReadRef
9BrFalse(11)
B1:
10Branch(13)
B2:
11LdConst[15](u64: 4018)
12Abort
B3:
13Ret
}
 
public get_global_config_info(Arg0: &GlobalConfig): GlobalConfigInfo {
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1ImmBorrowField[12](GlobalConfig.total_pools_created: u64)
2ReadRef
3MoveLoc[0](Arg0: &GlobalConfig)
4ImmBorrowField[3](GlobalConfig.max_quote_assets_per_pool: u64)
5ReadRef
6Pack[41](GlobalConfigInfo)
7Ret
}
 
public get_global_config_inner(Arg0: &GlobalConfigInfo): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &GlobalConfigInfo)
1ImmBorrowField[64](GlobalConfigInfo.total_pools_created: u64)
2ReadRef
3MoveLoc[0](Arg0: &GlobalConfigInfo)
4ImmBorrowField[65](GlobalConfigInfo.max_quote_assets_per_pool: u64)
5ReadRef
6Ret
}
 
public get_global_fee_info(Arg0: &GlobalConfig): GlobalFeeInfo {
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1ImmBorrowField[4](GlobalConfig.max_swap_fee_pct: u64)
2ReadRef
3CopyLoc[0](Arg0: &GlobalConfig)
4ImmBorrowField[5](GlobalConfig.max_lp_withdrawal_fee_pct: u64)
5ReadRef
6CopyLoc[0](Arg0: &GlobalConfig)
7ImmBorrowField[6](GlobalConfig.max_lp_fee_share: u64)
8ReadRef
9MoveLoc[0](Arg0: &GlobalConfig)
10ImmBorrowField[7](GlobalConfig.max_dynamic_fee: u64)
11ReadRef
12Pack[42](GlobalFeeInfo)
13Ret
}
 
public get_global_fee_inner(Arg0: &GlobalFeeInfo): u64 * u64 * u64 * u64 {
B0:
0CopyLoc[0](Arg0: &GlobalFeeInfo)
1ImmBorrowField[66](GlobalFeeInfo.max_swap_fee_pct: u64)
2ReadRef
3CopyLoc[0](Arg0: &GlobalFeeInfo)
4ImmBorrowField[67](GlobalFeeInfo.max_lp_withdrawal_fee_pct: u64)
5ReadRef
6CopyLoc[0](Arg0: &GlobalFeeInfo)
7ImmBorrowField[68](GlobalFeeInfo.max_lp_fee_share: u64)
8ReadRef
9MoveLoc[0](Arg0: &GlobalFeeInfo)
10ImmBorrowField[69](GlobalFeeInfo.max_dynamic_fee: u64)
11ReadRef
12Ret
}
 
public is_protocol_paused(Arg0: &GlobalConfig): bool {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1ImmBorrowField[70](GlobalConfig.is_protocol_paused: bool)
2ReadRef
3Ret
}
 
public get_pool_detailed_info_inner<Ty0>(Arg0: &PoolDetailedInfo<Ty0>): String * PoolInfo * PoolConfig * vector<String> * vector<RewardRPSEntry> * bool * address * u64 * bool {
B0:
0CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
1ImmBorrowFieldGeneric[36](PoolDetailedInfo.base_asset: String)
2ReadRef
3CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
4ImmBorrowFieldGeneric[37](PoolDetailedInfo.info: PoolInfo)
5ReadRef
6CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
7ImmBorrowFieldGeneric[38](PoolDetailedInfo.config: PoolConfig)
8ReadRef
9CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
10ImmBorrowFieldGeneric[39](PoolDetailedInfo.supported_quotes: vector<String>)
11ReadRef
12CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
13ImmBorrowFieldGeneric[40](PoolDetailedInfo.reward_rps: vector<RewardRPSEntry>)
14ReadRef
15CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
16ImmBorrowFieldGeneric[41](PoolDetailedInfo.is_paused: bool)
17ReadRef
18CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
19ImmBorrowFieldGeneric[42](PoolDetailedInfo.admin: address)
20ReadRef
21CopyLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
22ImmBorrowFieldGeneric[43](PoolDetailedInfo.limit_ratio: u64)
23ReadRef
24MoveLoc[0](Arg0: &PoolDetailedInfo<Ty0>)
25ImmBorrowFieldGeneric[44](PoolDetailedInfo.is_permissioned: bool)
26ReadRef
27Ret
}
 
public get_pool_detailed_info<Ty0>(Arg0: &LiquidityPool<Ty0>): PoolDetailedInfo<Ty0> {
L1: loc0: u128
L2: loc1: vector<String>
L3: loc2: String
L4: loc3: String
L5: loc4: u64
L6: loc5: vector<RewardRPSEntry>
L7: loc6: u128
L8: loc7: vector<String>
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1Call type_name::into_string(TypeName): String
2StLoc[4](loc3: String)
3CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
4Call get_supported_quotes<Ty0>(&LiquidityPool<Ty0>): vector<String>
5StLoc[8](loc7: vector<String>)
6VecPack(207, 0)
7StLoc[6](loc5: vector<RewardRPSEntry>)
8VecPack(128, 0)
9StLoc[2](loc1: vector<String>)
10MutBorrowLoc[2](loc1: vector<String>)
11CopyLoc[4](loc3: String)
12VecPushBack(128)
13MutBorrowLoc[2](loc1: vector<String>)
14CopyLoc[8](loc7: vector<String>)
15Call vector::append<String>(&mut vector<String>, vector<String>)
16LdU64(0)
17StLoc[5](loc4: u64)
B1:
18CopyLoc[5](loc4: u64)
19ImmBorrowLoc[2](loc1: vector<String>)
20VecLen(128)
21Lt
22BrFalse(55)
B2:
23Branch(24)
B3:
24ImmBorrowLoc[2](loc1: vector<String>)
25CopyLoc[5](loc4: u64)
26VecImmBorrow(128)
27ReadRef
28StLoc[3](loc2: String)
29CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
30ImmBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
31CopyLoc[3](loc2: String)
32Call table::contains<String, u128>(&Table<String, u128>, String): bool
33BrFalse(41)
B4:
34CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
35ImmBorrowFieldGeneric[3](LiquidityPool.reward_rps: Table<String, u128>)
36CopyLoc[3](loc2: String)
37Call table::borrow<String, u128>(&Table<String, u128>, String): &u128
38ReadRef
39StLoc[1](loc0: u128)
40Branch(43)
B5:
41LdU128(0)
42StLoc[1](loc0: u128)
B6:
43MoveLoc[1](loc0: u128)
44StLoc[7](loc6: u128)
45MutBorrowLoc[6](loc5: vector<RewardRPSEntry>)
46MoveLoc[3](loc2: String)
47MoveLoc[7](loc6: u128)
48Pack[44](RewardRPSEntry)
49VecPushBack(207)
50MoveLoc[5](loc4: u64)
51LdU64(1)
52Add
53StLoc[5](loc4: u64)
54Branch(18)
B7:
55MoveLoc[4](loc3: String)
56CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
57Call get_pool_info<Ty0>(&LiquidityPool<Ty0>): PoolInfo
58CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
59Call get_pool_config<Ty0>(&LiquidityPool<Ty0>): PoolConfig
60MoveLoc[8](loc7: vector<String>)
61MoveLoc[6](loc5: vector<RewardRPSEntry>)
62CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
63ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
64ReadRef
65CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
66ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
67ReadRef
68CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
69ImmBorrowFieldGeneric[10](LiquidityPool.limit_ratio: u64)
70ReadRef
71MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
72ImmBorrowFieldGeneric[17](LiquidityPool.is_permissioned: bool)
73ReadRef
74PackGeneric[23](PoolDetailedInfo<Ty0>)
75Ret
}
 
public get_pool_info<Ty0>(Arg0: &LiquidityPool<Ty0>): PoolInfo {
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
2Call object::uid_to_inner(&UID): ID
3CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
5Call balance::value<Ty0>(&Balance<Ty0>): u64
6CastU64
7CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
8Call net_base_added<Ty0>(&LiquidityPool<Ty0>): u64
9CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
10ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
11ReadRef
12CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
13ImmBorrowFieldGeneric[2](LiquidityPool.protocol_base_fees: Balance<Ty0>)
14Call balance::value<Ty0>(&Balance<Ty0>): u64
15CastU64
16CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
17ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
18ReadRef
19MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
20ImmBorrowFieldGeneric[12](LiquidityPool.is_paused: bool)
21ReadRef
22Pack[46](PoolInfo)
23Ret
}
 
public pool_info_inner(Arg0: &PoolInfo): ID * u64 * u64 * u64 * u64 * address * bool {
B0:
0CopyLoc[0](Arg0: &PoolInfo)
1ImmBorrowField[80](PoolInfo.id: ID)
2ReadRef
3CopyLoc[0](Arg0: &PoolInfo)
4ImmBorrowField[81](PoolInfo.base_liquidity: u64)
5ReadRef
6CopyLoc[0](Arg0: &PoolInfo)
7ImmBorrowField[82](PoolInfo.net_base_added: u64)
8ReadRef
9CopyLoc[0](Arg0: &PoolInfo)
10ImmBorrowField[83](PoolInfo.total_lp_shares: u64)
11ReadRef
12CopyLoc[0](Arg0: &PoolInfo)
13ImmBorrowField[84](PoolInfo.protocol_base_fees: u64)
14ReadRef
15CopyLoc[0](Arg0: &PoolInfo)
16ImmBorrowField[85](PoolInfo.admin: address)
17ReadRef
18MoveLoc[0](Arg0: &PoolInfo)
19ImmBorrowField[86](PoolInfo.is_paused: bool)
20ReadRef
21Ret
}
 
public get_pool_config<Ty0>(Arg0: &LiquidityPool<Ty0>): PoolConfig {
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
2ReadRef
3CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[7](LiquidityPool.lp_withdrawal_fee_pct: u64)
5ReadRef
6CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
7ImmBorrowFieldGeneric[8](LiquidityPool.lp_fee_pct: u64)
8ReadRef
9CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
10ImmBorrowFieldGeneric[9](LiquidityPool.max_dynamic_fee: u64)
11ReadRef
12CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
13ImmBorrowFieldGeneric[10](LiquidityPool.limit_ratio: u64)
14ReadRef
15MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
16ImmBorrowFieldGeneric[11](LiquidityPool.min_base_out: u64)
17ReadRef
18Pack[47](PoolConfig)
19Ret
}
 
public pool_config_inner(Arg0: &PoolConfig): u64 * u64 * u64 * u64 * u64 * u64 {
B0:
0CopyLoc[0](Arg0: &PoolConfig)
1ImmBorrowField[87](PoolConfig.swap_fee_pct: u64)
2ReadRef
3CopyLoc[0](Arg0: &PoolConfig)
4ImmBorrowField[88](PoolConfig.lp_withdrawal_fee_pct: u64)
5ReadRef
6CopyLoc[0](Arg0: &PoolConfig)
7ImmBorrowField[89](PoolConfig.lp_fee_pct: u64)
8ReadRef
9CopyLoc[0](Arg0: &PoolConfig)
10ImmBorrowField[90](PoolConfig.max_dynamic_fee: u64)
11ReadRef
12CopyLoc[0](Arg0: &PoolConfig)
13ImmBorrowField[91](PoolConfig.limit_ratio: u64)
14ReadRef
15MoveLoc[0](Arg0: &PoolConfig)
16ImmBorrowField[92](PoolConfig.min_base_out: u64)
17ReadRef
18Ret
}
 
public get_supported_quotes<Ty0>(Arg0: &LiquidityPool<Ty0>): vector<String> {
L1: loc0: String
L2: loc1: u64
L3: loc2: String
L4: loc3: vector<String>
B0:
0VecPack(128, 0)
1StLoc[4](loc3: vector<String>)
2Call type_name::with_defining_ids<Ty0>(): TypeName
3Call type_name::into_string(TypeName): String
4StLoc[1](loc0: String)
5LdU64(0)
6StLoc[2](loc1: u64)
B1:
7CopyLoc[2](loc1: u64)
8CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
9ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
10VecLen(128)
11Lt
12BrFalse(32)
B2:
13Branch(14)
B3:
14CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
15ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
16CopyLoc[2](loc1: u64)
17VecImmBorrow(128)
18ReadRef
19StLoc[3](loc2: String)
20CopyLoc[3](loc2: String)
21CopyLoc[1](loc0: String)
22Neq
23BrFalse(27)
B4:
24MutBorrowLoc[4](loc3: vector<String>)
25MoveLoc[3](loc2: String)
26VecPushBack(128)
B5:
27MoveLoc[2](loc1: u64)
28LdU64(1)
29Add
30StLoc[2](loc1: u64)
31Branch(7)
B6:
32MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
33Pop
34MoveLoc[4](loc3: vector<String>)
35Ret
}
 
public get_supported_assets_info<Ty0>(Arg0: &LiquidityPool<Ty0>): SupportedAssetsInfo {
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1Call type_name::into_string(TypeName): String
2MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
3Call get_supported_quotes<Ty0>(&LiquidityPool<Ty0>): vector<String>
4Pack[48](SupportedAssetsInfo)
5Ret
}
 
public get_supported_assets_inner<Ty0>(Arg0: &LiquidityPool<Ty0>): String * vector<String> {
L1: loc0: SupportedAssetsInfo
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1Call get_supported_assets_info<Ty0>(&LiquidityPool<Ty0>): SupportedAssetsInfo
2StLoc[1](loc0: SupportedAssetsInfo)
3ImmBorrowLoc[1](loc0: SupportedAssetsInfo)
4ImmBorrowField[93](SupportedAssetsInfo.base_asset: String)
5ReadRef
6ImmBorrowLoc[1](loc0: SupportedAssetsInfo)
7ImmBorrowField[94](SupportedAssetsInfo.supported_quotes: vector<String>)
8ReadRef
9Ret
}
 
public get_admin<Ty0>(Arg0: &LiquidityPool<Ty0>): address {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
2ReadRef
3Ret
}
 
public get_base_by_lp<Ty0>(Arg0: &LPPosition<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &LPPosition<Ty0>)
1ImmBorrowFieldGeneric[27](LPPosition.shares: u64)
2ReadRef
3LdConst[34](u64: 1000)
4Div
5Ret
}
 
public get_withdrawable_base_by_lp<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: &LPPosition<Ty0>): WithdrawableBaseByLp {
L2: loc0: u64
L3: loc1: u64
L4: loc2: u64
L5: loc3: u64
B0:
0MoveLoc[1](Arg1: &LPPosition<Ty0>)
1Call get_base_by_lp<Ty0>(&LPPosition<Ty0>): u64
2CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
3ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
4Call balance::value<Ty0>(&Balance<Ty0>): u64
5Call u64::min(u64, u64): u64
6StLoc[2](loc0: u64)
7CopyLoc[2](loc0: u64)
8MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
9ImmBorrowFieldGeneric[7](LiquidityPool.lp_withdrawal_fee_pct: u64)
10ReadRef
11Call calculate_net_and_fee_amount(u64, u64): u64 * u64
12StLoc[4](loc2: u64)
13StLoc[5](loc3: u64)
14MoveLoc[2](loc0: u64)
15LdConst[34](u64: 1000)
16Mul
17StLoc[3](loc1: u64)
18MoveLoc[5](loc3: u64)
19MoveLoc[4](loc2: u64)
20MoveLoc[3](loc1: u64)
21Pack[49](WithdrawableBaseByLp)
22Ret
}
 
public withdrawable_base_by_lp_inner(Arg0: &WithdrawableBaseByLp): u64 * u64 * u64 {
B0:
0CopyLoc[0](Arg0: &WithdrawableBaseByLp)
1ImmBorrowField[95](WithdrawableBaseByLp.withdrawable_base: u64)
2ReadRef
3CopyLoc[0](Arg0: &WithdrawableBaseByLp)
4ImmBorrowField[96](WithdrawableBaseByLp.withdraw_fee: u64)
5ReadRef
6MoveLoc[0](Arg0: &WithdrawableBaseByLp)
7ImmBorrowField[97](WithdrawableBaseByLp.shares_to_burn: u64)
8ReadRef
9Ret
}
 
public get_base_liquidity_info<Ty0>(Arg0: &LiquidityPool<Ty0>): BaseLiquidityInfo<Ty0> {
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
2Call balance::value<Ty0>(&Balance<Ty0>): u64
3MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
5ReadRef
6PackGeneric[24](BaseLiquidityInfo<Ty0>)
7Ret
}
 
public get_base_liquidity_inner<Ty0>(Arg0: &LiquidityPool<Ty0>): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[13](LiquidityPool.base_reserve: Balance<Ty0>)
2Call balance::value<Ty0>(&Balance<Ty0>): u64
3MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[30](LiquidityPool.total_lp_shares: u64)
5ReadRef
6Ret
}
 
public get_lp_position_info<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: &LPPosition<Ty0>): LPPositionInfo {
L2: loc0: u128
L3: loc1: vector<String>
L4: loc2: String
L5: loc3: String
L6: loc4: ClaimableRewardsInfo
L7: loc5: vector<ClaimableRewardsInfo>
L8: loc6: u64
L9: loc7: u64
L10: loc8: vector<PaidRPSEntry>
L11: loc9: u128
L12: loc10: vector<String>
B0:
0VecPack(29, 0)
1StLoc[7](loc5: vector<ClaimableRewardsInfo>)
2LdU64(0)
3StLoc[8](loc6: u64)
B1:
4CopyLoc[8](loc6: u64)
5CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
6ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
7VecLen(128)
8Lt
9BrFalse(24)
B2:
10Branch(11)
B3:
11CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
12CopyLoc[1](Arg1: &LPPosition<Ty0>)
13CopyLoc[8](loc6: u64)
14Call calc_claimable_rewards<Ty0>(&LiquidityPool<Ty0>, &LPPosition<Ty0>, u64): ClaimableRewardsInfo
15StLoc[6](loc4: ClaimableRewardsInfo)
16MutBorrowLoc[7](loc5: vector<ClaimableRewardsInfo>)
17MoveLoc[6](loc4: ClaimableRewardsInfo)
18VecPushBack(29)
19MoveLoc[8](loc6: u64)
20LdU64(1)
21Add
22StLoc[8](loc6: u64)
23Branch(4)
B4:
24MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
25Call get_supported_quotes<Ty0>(&LiquidityPool<Ty0>): vector<String>
26StLoc[12](loc10: vector<String>)
27VecPack(211, 0)
28StLoc[10](loc8: vector<PaidRPSEntry>)
29Call type_name::with_defining_ids<Ty0>(): TypeName
30Call type_name::into_string(TypeName): String
31StLoc[5](loc3: String)
32VecPack(128, 0)
33StLoc[3](loc1: vector<String>)
34MutBorrowLoc[3](loc1: vector<String>)
35MoveLoc[5](loc3: String)
36VecPushBack(128)
37MutBorrowLoc[3](loc1: vector<String>)
38MoveLoc[12](loc10: vector<String>)
39Call vector::append<String>(&mut vector<String>, vector<String>)
40LdU64(0)
41StLoc[9](loc7: u64)
B5:
42CopyLoc[9](loc7: u64)
43ImmBorrowLoc[3](loc1: vector<String>)
44VecLen(128)
45Lt
46BrFalse(79)
B6:
47Branch(48)
B7:
48ImmBorrowLoc[3](loc1: vector<String>)
49CopyLoc[9](loc7: u64)
50VecImmBorrow(128)
51ReadRef
52StLoc[4](loc2: String)
53CopyLoc[1](Arg1: &LPPosition<Ty0>)
54ImmBorrowFieldGeneric[28](LPPosition.paid_rps: Table<String, u128>)
55CopyLoc[4](loc2: String)
56Call table::contains<String, u128>(&Table<String, u128>, String): bool
57BrFalse(65)
B8:
58CopyLoc[1](Arg1: &LPPosition<Ty0>)
59ImmBorrowFieldGeneric[28](LPPosition.paid_rps: Table<String, u128>)
60CopyLoc[4](loc2: String)
61Call table::borrow<String, u128>(&Table<String, u128>, String): &u128
62ReadRef
63StLoc[2](loc0: u128)
64Branch(67)
B9:
65LdU128(0)
66StLoc[2](loc0: u128)
B10:
67MoveLoc[2](loc0: u128)
68StLoc[11](loc9: u128)
69MutBorrowLoc[10](loc8: vector<PaidRPSEntry>)
70MoveLoc[4](loc2: String)
71MoveLoc[11](loc9: u128)
72Pack[45](PaidRPSEntry)
73VecPushBack(211)
74MoveLoc[9](loc7: u64)
75LdU64(1)
76Add
77StLoc[9](loc7: u64)
78Branch(42)
B11:
79CopyLoc[1](Arg1: &LPPosition<Ty0>)
80ImmBorrowFieldGeneric[26](LPPosition.pool_id: ID)
81ReadRef
82MoveLoc[1](Arg1: &LPPosition<Ty0>)
83ImmBorrowFieldGeneric[27](LPPosition.shares: u64)
84ReadRef
85MoveLoc[7](loc5: vector<ClaimableRewardsInfo>)
86MoveLoc[10](loc8: vector<PaidRPSEntry>)
87Pack[51](LPPositionInfo)
88Ret
}
 
public get_claimable_rewards_info<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: &LPPosition<Ty0>): vector<ClaimableRewardsInfo> {
L2: loc0: ClaimableRewardsInfo
L3: loc1: vector<ClaimableRewardsInfo>
L4: loc2: u64
B0:
0VecPack(29, 0)
1StLoc[3](loc1: vector<ClaimableRewardsInfo>)
2LdU64(0)
3StLoc[4](loc2: u64)
B1:
4CopyLoc[4](loc2: u64)
5CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
6ImmBorrowFieldGeneric[4](LiquidityPool.supported_assets: vector<String>)
7VecLen(128)
8Lt
9BrFalse(24)
B2:
10Branch(11)
B3:
11CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
12CopyLoc[1](Arg1: &LPPosition<Ty0>)
13CopyLoc[4](loc2: u64)
14Call calc_claimable_rewards<Ty0>(&LiquidityPool<Ty0>, &LPPosition<Ty0>, u64): ClaimableRewardsInfo
15StLoc[2](loc0: ClaimableRewardsInfo)
16MutBorrowLoc[3](loc1: vector<ClaimableRewardsInfo>)
17MoveLoc[2](loc0: ClaimableRewardsInfo)
18VecPushBack(29)
19MoveLoc[4](loc2: u64)
20LdU64(1)
21Add
22StLoc[4](loc2: u64)
23Branch(4)
B4:
24MoveLoc[1](Arg1: &LPPosition<Ty0>)
25Pop
26MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
27Pop
28MoveLoc[3](loc1: vector<ClaimableRewardsInfo>)
29Ret
}
 
public lp_position_info_inner(Arg0: &LPPositionInfo): ID * u64 * vector<ClaimableRewardsInfo> * vector<PaidRPSEntry> {
B0:
0CopyLoc[0](Arg0: &LPPositionInfo)
1ImmBorrowField[98](LPPositionInfo.pool_id: ID)
2ReadRef
3CopyLoc[0](Arg0: &LPPositionInfo)
4ImmBorrowField[99](LPPositionInfo.shares: u64)
5ReadRef
6CopyLoc[0](Arg0: &LPPositionInfo)
7ImmBorrowField[100](LPPositionInfo.claimable_rewards: vector<ClaimableRewardsInfo>)
8ReadRef
9MoveLoc[0](Arg0: &LPPositionInfo)
10ImmBorrowField[101](LPPositionInfo.paid_rps: vector<PaidRPSEntry>)
11ReadRef
12Ret
}
 
public get_protocol_fees_info<Ty0>(Arg0: &LiquidityPool<Ty0>): ProtocolFeesInfo {
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
2ReadRef
3MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[7](LiquidityPool.lp_withdrawal_fee_pct: u64)
5ReadRef
6Pack[52](ProtocolFeesInfo)
7Ret
}
 
public get_protocol_fees_inner<Ty0>(Arg0: &LiquidityPool<Ty0>): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[6](LiquidityPool.swap_fee_pct: u64)
2ReadRef
3MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[7](LiquidityPool.lp_withdrawal_fee_pct: u64)
5ReadRef
6Ret
}
 
public get_permissioned<Ty0>(Arg0: &LiquidityPool<Ty0>): bool {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[17](LiquidityPool.is_permissioned: bool)
2ReadRef
3Ret
}
 
public get_whitelisted_lps<Ty0>(Arg0: &LiquidityPool<Ty0>): vector<address> {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[16](LiquidityPool.whitelisted_lps: vector<address>)
2ReadRef
3Ret
}
 
public validate_global_config_version(Arg0: &GlobalConfig) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1ImmBorrowField[0](GlobalConfig.version: u64)
2ReadRef
3Call constants::get_version(): u64
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[9](u64: 4011)
8Abort
B3:
9Ret
}
 
public validate_pool_version<Ty0>(Arg0: &LiquidityPool<Ty0>) {
B0:
0MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
1ImmBorrowFieldGeneric[0](LiquidityPool.version: u64)
2ReadRef
3Call constants::get_version(): u64
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[9](u64: 4011)
8Abort
B3:
9Ret
}
 
public quote_asset_info_inner(Arg0: QuoteAssetInfo): u64 * u64 * u64 * u64 * Option<u64> * Option<u64> * u64 * bool {
B0:
0ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
1ImmBorrowField[102](QuoteAssetInfo.ideal_reserve_pct: u64)
2ReadRef
3ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
4ImmBorrowField[103](QuoteAssetInfo.max_reserve_pct: u64)
5ReadRef
6ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
7ImmBorrowField[104](QuoteAssetInfo.fee_base: u64)
8ReadRef
9ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
10ImmBorrowField[105](QuoteAssetInfo.fee_max: u64)
11ReadRef
12ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
13ImmBorrowField[106](QuoteAssetInfo.limit_ratio: Option<u64>)
14ReadRef
15ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
16ImmBorrowField[107](QuoteAssetInfo.limit_fixed: Option<u64>)
17ReadRef
18ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
19ImmBorrowField[108](QuoteAssetInfo.min_out: u64)
20ReadRef
21ImmBorrowLoc[0](Arg0: QuoteAssetInfo)
22ImmBorrowField[109](QuoteAssetInfo.is_trading: bool)
23ReadRef
24Ret
}
 
public get_quote_asset_info<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>): QuoteAssetInfo {
L1: loc0: String
L2: loc1: &QuoteAssetReserve<Ty1>
B0:
0Call type_name::with_defining_ids<Ty1>(): TypeName
1Call type_name::into_string(TypeName): String
2StLoc[1](loc0: String)
3CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
5CopyLoc[1](loc0: String)
6Call dynamic_field::exists_<String>(&UID, String): bool
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
10Pop
11LdConst[3](u64: 4003)
12Abort
B3:
13MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
14ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
15CopyLoc[1](loc0: String)
16Call dynamic_field::borrow<String, QuoteAssetReserve<Ty1>>(&UID, String): &QuoteAssetReserve<Ty1>
17StLoc[2](loc1: &QuoteAssetReserve<Ty1>)
18MoveLoc[1](loc0: String)
19CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
20ImmBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
21Call balance::value<Ty1>(&Balance<Ty1>): u64
22CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
23ImmBorrowFieldGeneric[18](QuoteAssetReserve.ideal_reserve_pct: u64)
24ReadRef
25CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
26ImmBorrowFieldGeneric[19](QuoteAssetReserve.max_reserve_pct: u64)
27ReadRef
28CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
29ImmBorrowFieldGeneric[20](QuoteAssetReserve.fee_base: u64)
30ReadRef
31CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
32ImmBorrowFieldGeneric[21](QuoteAssetReserve.fee_max: u64)
33ReadRef
34CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
35ImmBorrowFieldGeneric[22](QuoteAssetReserve.limit_ratio: Option<u64>)
36ReadRef
37CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
38ImmBorrowFieldGeneric[23](QuoteAssetReserve.limit_fixed: Option<u64>)
39ReadRef
40CopyLoc[2](loc1: &QuoteAssetReserve<Ty1>)
41ImmBorrowFieldGeneric[24](QuoteAssetReserve.min_out: u64)
42ReadRef
43MoveLoc[2](loc1: &QuoteAssetReserve<Ty1>)
44ImmBorrowFieldGeneric[25](QuoteAssetReserve.is_trading: bool)
45ReadRef
46Pack[53](QuoteAssetInfo)
47Ret
}
 
public get_quote_balance<Ty0, Ty1>(Arg0: &LiquidityPool<Ty0>): u64 {
L1: loc0: String
B0:
0Call type_name::with_defining_ids<Ty1>(): TypeName
1Call type_name::into_string(TypeName): String
2StLoc[1](loc0: String)
3CopyLoc[0](Arg0: &LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
5CopyLoc[1](loc0: String)
6Call dynamic_field::exists_<String>(&UID, String): bool
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
10Pop
11LdConst[3](u64: 4003)
12Abort
B3:
13MoveLoc[0](Arg0: &LiquidityPool<Ty0>)
14ImmBorrowFieldGeneric[1](LiquidityPool.id: UID)
15MoveLoc[1](loc0: String)
16Call dynamic_field::borrow<String, QuoteAssetReserve<Ty1>>(&UID, String): &QuoteAssetReserve<Ty1>
17ImmBorrowFieldGeneric[14](QuoteAssetReserve.balance: Balance<Ty1>)
18Call balance::value<Ty1>(&Balance<Ty1>): u64
19Ret
}
 
table_upsert<Ty0: drop + store>(Arg0: &mut Table<String, Ty0>, Arg1: String, Arg2: Ty0) {
B0:
0CopyLoc[0](Arg0: &mut Table<String, Ty0>)
1FreezeRef
2CopyLoc[1](Arg1: String)
3Call table::contains<String, Ty0>(&Table<String, Ty0>, String): bool
4BrFalse(11)
B1:
5MoveLoc[2](Arg2: Ty0)
6MoveLoc[0](Arg0: &mut Table<String, Ty0>)
7MoveLoc[1](Arg1: String)
8Call table::borrow_mut<String, Ty0>(&mut Table<String, Ty0>, String): &mut Ty0
9WriteRef
10Branch(15)
B2:
11MoveLoc[0](Arg0: &mut Table<String, Ty0>)
12MoveLoc[1](Arg1: String)
13MoveLoc[2](Arg2: Ty0)
14Call table::add<String, Ty0>(&mut Table<String, Ty0>, String, Ty0)
B3:
15Ret
}
 
public claim_owned_coins<Ty0, Ty1: store + key>(Arg0: &ProtocolAdminCap, Arg1: &mut LiquidityPool<Ty0>, Arg2: Receiving<Ty1>, Arg3: &mut TxContext): Ty1 {
B0:
0CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
1FreezeRef
2Call validate_pool_version<Ty0>(&LiquidityPool<Ty0>)
3CopyLoc[1](Arg1: &mut LiquidityPool<Ty0>)
4ImmBorrowFieldGeneric[5](LiquidityPool.admin: address)
5ReadRef
6MoveLoc[3](Arg3: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
13Pop
14LdConst[2](u64: 4002)
15Abort
B3:
16MoveLoc[1](Arg1: &mut LiquidityPool<Ty0>)
17MutBorrowFieldGeneric[1](LiquidityPool.id: UID)
18MoveLoc[2](Arg2: Receiving<Ty1>)
19Call transfer::public_receive<Ty1>(&mut UID, Receiving<Ty1>): Ty1
20Ret
}
 
public version(): u64 {
B0:
0Call constants::get_version(): u64
1Ret
}
 
public update_module_version(Arg0: &mut GlobalConfig) {
B0:
0LdConst[16](u64: 4019)
1Abort
}
 
public update_pool_version<Ty0>(Arg0: &mut LiquidityPool<Ty0>) {
B0:
0LdConst[16](u64: 4019)
1Abort
}
 
public update_claimable_rewards<Ty0>(Arg0: &LiquidityPool<Ty0>, Arg1: &mut LPPosition<Ty0>) {
B0:
0LdConst[16](u64: 4019)
1Abort
}
 
Constants [
0 => u64: 4000
1 => u64: 4001
2 => u64: 4002
3 => u64: 4003
4 => u64: 4005
5 => u64: 4007
6 => u64: 4008
7 => u64: 4009
8 => u64: 4010
9 => u64: 4011
10 => u64: 4012
11 => u64: 4013
12 => u64: 4014
13 => u64: 4016
14 => u64: 4017
15 => u64: 4018
16 => u64: 4019
17 => u64: 4020
18 => u64: 4021
19 => u64: 4022
20 => u64: 4023
21 => u64: 4024
22 => u64: 4025
23 => u64: 4026
24 => u64: 4027
25 => u64: 4028
26 => u64: 4029
27 => u64: 4030
28 => u64: 4031
29 => u64: 4032
30 => u64: 4033
31 => u128: 1000000000000000000
32 => u64: 10000
33 => u128: 10000
34 => u64: 1000
35 => u64: 9000
]
}