SUI$0.85518.12%

DEEP$0.01487.07%

WAL$0.02882.87%

CETUS$0.02004.92%

NAVX$0.009654.16%

IKA$0.0014417.33%

HAEDAL$0.02671.89%

MMT$0.12044.64%

BLUE$0.007815.80%

NS$0.009975.09%

USDT$0.99900.01%

haSUI$0.92907.69%

SUI$0.85518.12%

DEEP$0.01487.07%

WAL$0.02882.87%

CETUS$0.02004.92%

NAVX$0.009654.16%

IKA$0.0014417.33%

HAEDAL$0.02671.89%

MMT$0.12044.64%

BLUE$0.007815.80%

NS$0.009975.09%

USDT$0.99900.01%

haSUI$0.92907.69%

/

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

Markets Network Data Intel

Data from

Explore

Home
Checkpoints
Epochs
Validators
Markets
NFTs

Network

Overview
Mainnet

Resources

API docs
API keys
Check a tx
API status

@pkg/fullsail-clmm::pool declarations | tide

Packages@pkg/fullsail-clmmpool

pool

Module0x497a…a881

Move path: 0xe741…b239::pool
Functions: 11193 public, 0 entry
Structs: 33
Friend modules: factory

Modules

acl13
clmm_math14
config34
factory13
partner14
pool111
position56
rewarder22
stats3
tick31
tick_math11
utils1

pool

acl13
clmm_math14
config34
factory13
partner14
pool111
position56
rewarder22
stats3
tick31
tick_math11
utils1

Interface Source Bytecode

Module views

Declarations

Rebuilt from the module interface. No verified source is published, and function bodies are only available as bytecode.

module pool;

struct AddLiquidityEvent has copy, drop, store {

pool: ID,

position: ID,

tick_lower: i32::I32,

tick_upper: i32::I32,

liquidity: ,

u128

after_liquidity: u128,

amount_a: u64,

amount_b: u64,

}

struct AddLiquidityReceipt<phantom T0, phantom T1> {

pool_id: ID,

amount_a: u64,

amount_b: u64,

}

struct AddRewarderEvent has copy, drop, store {

pool: ID,

rewarder_type: TypeName,

}

struct CalculatedSwapResult has copy, drop, store {

amount_in: u64,

amount_out: u64,

fee_amount: u64,

fee_rate: u64,

ref_fee_amount: u64,

gauge_fee_amount: u64,

protocol_fee_amount: u64,

after_sqrt_price: u128,

is_exceed: bool,

step_results: vector<SwapStepResult>,

}

struct ClosePositionEvent has copy, drop, store {

pool: ID,

position: ID,

}

struct CollectFeeEvent has copy, drop, store {

position: ID,

pool: ID,

amount_a: u64,

amount_b: u64,

}

struct CollectGaugeFeeEvent has copy, drop, store {

pool: ID,

amount_a: u64,

amount_b: u64,

}

struct CollectProtocolFeeEvent has copy, drop, store {

pool: ID,

amount_a: u64,

amount_b: u64,

}

struct CollectRewardEvent has copy, drop, store {

position: ID,

pool: ID,

amount: u64,

}

struct CollectRewardEventV2 has copy, drop, store {

position: ID,

pool: ID,

amount: u64,

token_type: TypeName,

}

struct FlashSwapReceipt<phantom T0, phantom T1> {

pool_id: ID,

a2b: bool,

partner_id: Option<ID>,

pay_amount: u64,

fee_amount: u64,

protocol_fee_amount: u64,

ref_fee_amount: u64,

gauge_fee_amount: u64,

}

struct InitFullsailDistributionGaugeEvent has copy, drop, store {

pool_id: ID,

gauge_id: ID,

}

struct OpenPositionEvent has copy, drop, store {

pool: ID,

tick_lower: i32::I32,

tick_upper: i32::I32,

position: ID,

}

struct POOL has drop {

dummy_field: bool,

}

struct PausePoolEvent has copy, drop, store {

pool_id: ID,

}

struct Pool<phantom T0, phantom T1> has store, key {

id: UID,

coin_a: Balance<T0>,

coin_b: Balance<T1>,

tick_spacing: u32,

fee_rate: u64,

liquidity: u128,

current_sqrt_price: u128,

current_tick_index: i32::I32,

fee_growth_global_a: u128,

fee_growth_global_b: u128,

fee_protocol_coin_a: u64,

fee_protocol_coin_b: u64,

tick_manager: tick::TickManager,

rewarder_manager: rewarder::RewarderManager,

position_manager: position::PositionManager,

is_pause: bool,

index: u64,

url: String,

unstaked_liquidity_fee_rate: u64,

fullsail_distribution_gauger_id: Option<ID>,

fullsail_distribution_growth_global: u128,

fullsail_distribution_rate: u128,

fullsail_distribution_reserve: u64,

fullsail_distribution_period_finish: u64,

fullsail_distribution_rollover: u64,

fullsail_distribution_last_updated: u64,

fullsail_distribution_staked_liquidity: u128,

fullsail_distribution_gauger_fee: PoolFee,

volume: PoolVolume,

feed_id: PoolFeedId,

auto_calculation_volumes: bool,

}

struct PoolFee has drop, store {

coin_a: u64,

coin_b: u64,

}

struct PoolFeedId has drop, store {

feed_id_coin_a: address,

feed_id_coin_b: address,

}

struct PoolVolume has drop, store {

volume_usd_coin_a: u128,

volume_usd_coin_b: u128,

}

struct RemoveLiquidityEvent has copy, drop, store {

pool: ID,

position: ID,

tick_lower: i32::I32,

tick_upper: i32::I32,

liquidity: u128,

after_liquidity: u128,

amount_a: u64,

amount_b: u64,

}

struct RestoreStakedLiquidityEvent has copy, drop, store {

pool_id: ID,

staked_liquidity_before: u128,

staked_liquidity_after: u128,

liquidity: u128,

}

struct SwapEvent has copy, drop, store {

atob: bool,

pool: ID,

partner: ID,

amount_in: u64,

amount_out: u64,

fullsail_fee_amount: u64,

protocol_fee_amount: u64,

ref_fee_amount: u64,

fee_amount: u64,

vault_a_amount: u64,

vault_b_amount: u64,

before_sqrt_price: u128,

after_sqrt_price: u128,

steps: u64,

}

struct SwapResult has copy, drop {

amount_in: u64,

amount_out: u64,

fee_amount: u64,

protocol_fee_amount: u64,

ref_fee_amount: u64,

gauge_fee_amount: u64,

steps: u64,

}

struct SwapStepResult has copy, drop, store {

current_sqrt_price: u128,

target_sqrt_price: u128,

current_liquidity: u128,

amount_in: u64,

amount_out: u64,

fee_amount: u64,

remainder_amount: u64,

}

struct SyncFullsailDistributionRewardEvent has copy, drop, store {

pool_id: ID,

gauge_id: ID,

distribution_rate: u128,

distribution_reserve: u64,

period_finish: u64,

rollover: u64,

}

struct UnpausePoolEvent has copy, drop, store {

pool_id: ID,

}

struct UpdateEmissionEvent has copy, drop, store {

pool: ID,

rewarder_type: TypeName,

emissions_per_second: u128,

}

struct UpdateFeeGrowthGlobalEvent has copy, drop, store {

pool_id: ID,

fee_growth_global_a: u128,

fee_growth_global_b: u128,

}

struct UpdateFeeRateEvent has copy, drop, store {

pool: ID,

old_fee_rate: u64,

new_fee_rate: u64,

}

struct UpdateFullsailDistributionGrowthGlobalEvent has copy, drop, store {

pool_id: ID,

growth_global: u128,

reserve: u64,

rollover: u64,

}

struct UpdateFullsailDistributionStakedLiquidityEvent has copy, drop, store {

pool_id: ID,

staked_liquidity: u128,

}

struct UpdatePoolUrlEvent has copy, drop, store {

pool: ID,

new_url: String,

}

struct UpdateUnstakedLiquidityFeeRateEvent has copy, drop, store {

pool: ID,

old_fee_rate: u64,

new_fee_rate: u64,

}

public fun add_liquidity<T0, T1>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,&mut position::Position,u128,&Clock): AddLiquidityReceipt<T0, T1>

public fun add_liquidity_fix_coin<T0, T1>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,&mut position::Position,u64,bool,&Clock): AddLiquidityReceipt<T0, T1>

fun add_liquidity_internal<T0, T1>(&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,&mut position::Position,bool,u128,u64,bool,u64): AddLiquidityReceipt<T0, T1>

public fun add_liquidity_pay_amount<T0, T1>(&AddLiquidityReceipt<T0, T1>): (u64, u64)

fun apply_unstaked_fees(u128,u128,u64): (u128, u128)

public fun balances<T0, T1>(&Pool<T0, T1>): (u64, u64)

public fun borrow_position_info<T0, T1>(&Pool<T0, T1>,ID): &position::PositionInfo

public fun borrow_tick<T0, T1>(&Pool<T0, T1>,i32::I32): &tick::Tick

public fun calculate_and_update_fee<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,ID): (u64, u64)

public fun calculate_and_update_fullsail_distribution<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,ID): u64

public fun calculate_and_update_points<T0, T1>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,ID,&Clock): u128

public fun calculate_and_update_reward<T0, T1, T2>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,ID,&Clock): u64

public fun calculate_and_update_rewards<T0, T1>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,ID,&Clock): vector<u64>

fun calculate_fees(u64,u128,u128,u64): (u128, u64)

public fun calculate_swap_result<T0, T1>(&config::GlobalConfig,&Pool<T0, T1>,bool,bool,u64): CalculatedSwapResult

fun calculate_swap_result_internal<T0, T1>(&config::GlobalConfig,&Pool<T0, T1>,bool,bool,u64,u64): CalculatedSwapResult

public fun calculate_swap_result_step_results(&CalculatedSwapResult): &vector<SwapStepResult>

public fun calculate_swap_result_with_partner<T0, T1>(&config::GlobalConfig,&Pool<T0, T1>,bool,bool,u64,u64): CalculatedSwapResult

public fun calculated_swap_result_after_sqrt_price(&CalculatedSwapResult): u128

public fun calculated_swap_result_amount_in(&CalculatedSwapResult): u64

public fun calculated_swap_result_amount_out(&CalculatedSwapResult): u64

public fun calculated_swap_result_fees_amount(&CalculatedSwapResult): (u64, u64, u64, u64)

public fun calculated_swap_result_is_exceed(&CalculatedSwapResult): bool

public fun calculated_swap_result_step_swap_result(&CalculatedSwapResult,u64): &SwapStepResult

public fun calculated_swap_result_steps_length(&CalculatedSwapResult): u64

fun check_gauge_cap<T0, T1>(&Pool<T0, T1>,&gauge_cap::GaugeCap)

fun check_remainer_amount_sub(u64, u64): u64

fun check_tick_range(i32::I32,i32::I32): bool

public fun close_position<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,position::Position)

public fun collect_fee<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,&position::Position,bool): (Balance<T0>, Balance<T1>)

public fun collect_fullsail_distribution_gauger_fees<T0, T1>(&mut Pool<T0, T1>,&gauge_cap::GaugeCap): (Balance<T0>, Balance<T1>)

public fun collect_protocol_fee<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>): (Balance<T0>, Balance<T1>)

public fun collect_reward<T0, T1, T2>(&config::GlobalConfig,&mut Pool<T0, T1>,&position::Position,&mut rewarder::RewarderGlobalVault,bool,&Clock): Balance<T2>

public fun current_sqrt_price<T0, T1>(&Pool<T0, T1>): u128

public fun current_tick_index<T0, T1>(&Pool<T0, T1>): i32::I32

fun default_swap_result(): SwapResult

public fun fee_rate<T0, T1>(&Pool<T0, T1>): u64

public fun fees_amount<T0, T1>(&FlashSwapReceipt<T0, T1>): (u64, u64, u64, u64)

public fun fees_growth_global<T0, T1>(&Pool<T0, T1>): (u128, u128)

public fun fetch_positions<T0, T1>(&Pool<T0, T1>,Option<ID>,u64): vector<position::PositionInfo>

public fun fetch_ticks<T0, T1>(&Pool<T0, T1>,Option<u32>,u64): vector<tick::Tick>

public fun flash_swap<T0, T1>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,bool,bool,u64,u128,&mut stats::Stats,&price_provider::PriceProvider,&Clock): (Balance<T0>, Balance<T1>, FlashSwapReceipt<T0, T1>)

fun flash_swap_internal<T0, T1>(&mut Pool<T0, T1>,&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,Option<ID>,u64,bool,bool,u64,u128,&mut stats::Stats,&price_provider::PriceProvider,&Clock): (Balance<T0>, Balance<T1>, FlashSwapReceipt<T0, T1>)

public fun flash_swap_with_partner<T0, T1>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,&partner::Partner,bool,bool,u64,u128,&mut stats::Stats,&price_provider::PriceProvider,&Clock): (Balance<T0>, Balance<T1>, FlashSwapReceipt<T0, T1>)

public fun fullsail_distribution_gauger_fee<T0, T1>(&Pool<T0, T1>): PoolFee

public fun get_all_growths_in_tick_range<T0, T1>(&Pool<T0, T1>,i32::I32,i32::I32): (u128, u128, vector<u128>, u128, u128)

public fun get_fee_in_tick_range<T0, T1>(&Pool<T0, T1>,i32::I32,i32::I32): (u128, u128)

public fun get_fullsail_distribution_gauger_id<T0, T1>(&Pool<T0, T1>): ID

public fun get_fullsail_distribution_growth_global<T0, T1>(&Pool<T0, T1>): u128

public fun get_fullsail_distribution_growth_inside<T0, T1>(&Pool<T0, T1>,i32::I32,i32::I32,u128): u128

public fun get_fullsail_distribution_last_updated<T0, T1>(&Pool<T0, T1>): u64

public fun get_fullsail_distribution_period_finish<T0, T1>(&Pool<T0, T1>): u64

public fun get_fullsail_distribution_reserve<T0, T1>(&Pool<T0, T1>): u64

public fun get_fullsail_distribution_rollover<T0, T1>(&Pool<T0, T1>): u64

public fun get_fullsail_distribution_staked_liquidity<T0, T1>(&Pool<T0, T1>): u128

public fun get_points_in_tick_range<T0, T1>(&Pool<T0, T1>,i32::I32,i32::I32): u128

public fun get_pool_volumes<T0, T1>(&Pool<T0, T1>): (u128, u128)

public fun get_position_amounts<T0, T1>(&Pool<T0, T1>,ID): (u64, u64)

public fun get_position_fee<T0, T1>(&Pool<T0, T1>,ID): (u64, u64)

public fun get_position_points<T0, T1>(&Pool<T0, T1>,ID): u128

public fun get_position_reward<T0, T1, T2>(&Pool<T0, T1>,ID): u64

public fun get_position_rewards<T0, T1>(&Pool<T0, T1>,ID): vector<u64>

public fun get_rewards_in_tick_range<T0, T1>(&Pool<T0, T1>,i32::I32,i32::I32): vector<u128>

public fun index<T0, T1>(&Pool<T0, T1>): u64

fun init(POOL)

public fun init_fullsail_distribution_gauge<T0, T1>(&mut Pool<T0, T1>,&gauge_cap::GaugeCap)

public fun initialize_rewarder<T0, T1, T2>(&config::GlobalConfig,&mut Pool<T0, T1>)

public fun is_pause<T0, T1>(&Pool<T0, T1>): bool

public fun is_position_exist<T0, T1>(&Pool<T0, T1>,ID): bool

public fun liquidity<T0, T1>(&Pool<T0, T1>): u128

public(package) fun new<T0, T1>(u32,u128,u64,String,u64,address,address,bool,&Clock): Pool<T0, T1>

public fun open_position<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,u32,u32): position::Position

public fun pause<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>)

public fun pool_fee_a_b(&PoolFee): (u64, u64)

public fun position_manager<T0, T1>(&Pool<T0, T1>): &position::PositionManager

public fun protocol_fee<T0, T1>(&Pool<T0, T1>): (u64, u64)

public fun remove_liquidity<T0, T1>(&config::GlobalConfig,&mut rewarder::RewarderGlobalVault,&mut Pool<T0, T1>,&mut position::Position,u128,&Clock): (Balance<T0>, Balance<T1>)

public fun repay_add_liquidity<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,Balance<T0>,Balance<T1>,AddLiquidityReceipt<T0, T1>)

public fun repay_flash_swap<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,Balance<T0>,Balance<T1>,FlashSwapReceipt<T0, T1>)

public fun repay_flash_swap_with_partner<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,&mut partner::Partner,Balance<T0>,Balance<T1>,FlashSwapReceipt<T0, T1>)

public fun restore_fullsail_distribution_staked_liquidity<T0, T1>(&mut Pool<T0, T1>,&config::GlobalConfig)

public fun rewarder_manager<T0, T1>(&Pool<T0, T1>): &rewarder::RewarderManager

public fun set_display<T0, T1>(&config::GlobalConfig,&Publisher,String,String,String,String,String,String)

fun split_fees(u64,u128,u128,u64): (u64, u64)

public fun stake_in_fullsail_distribution<T0, T1>(&mut Pool<T0, T1>,&gauge_cap::GaugeCap,&position::Position,&Clock)

public fun step_swap_result_amount_in(&SwapStepResult): u64

public fun step_swap_result_amount_out(&SwapStepResult): u64

public fun step_swap_result_current_liquidity(&SwapStepResult): u128

public fun step_swap_result_current_sqrt_price(&SwapStepResult): u128

public fun step_swap_result_fee_amount(&SwapStepResult): u64

public fun step_swap_result_remainder_amount(&SwapStepResult): u64

public fun step_swap_result_target_sqrt_price(&SwapStepResult): u128

fun swap_in_pool<T0, T1>(&mut Pool<T0, T1>,bool,bool,u128,u64,u64,u64,u64,&Clock): (SwapResult, u128)

public fun swap_pay_amount<T0, T1>(&FlashSwapReceipt<T0, T1>): u64

public fun sync_fullsail_distribution_reward<T0, T1>(&mut Pool<T0, T1>,&gauge_cap::GaugeCap,u128,u64,u64,&Clock)

public fun tick_manager<T0, T1>(&Pool<T0, T1>): &tick::TickManager

public fun tick_spacing<T0, T1>(&Pool<T0, T1>): u32

public fun unpause<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>)

public fun unstake_from_fullsail_distribution<T0, T1>(&mut Pool<T0, T1>,&gauge_cap::GaugeCap,&position::Position,&Clock)

public fun unstaked_liquidity_fee_rate<T0, T1>(&Pool<T0, T1>): u64

public fun update_emission<T0, T1, T2>(&config::GlobalConfig,&mut Pool<T0, T1>,&mut rewarder::RewarderGlobalVault,u128,&Clock)

fun update_fee_growth_global<T0, T1>(&mut Pool<T0, T1>,u128,bool)

public fun update_fee_rate<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,u64)

public fun update_fullsail_distribution_growth_global<T0, T1>(&mut Pool<T0, T1>,&gauge_cap::GaugeCap,&Clock)

fun update_fullsail_distribution_growth_global_internal<T0, T1>(&mut Pool<T0, T1>,&Clock): u64

fun update_fullsail_distribution_internal<T0, T1>(&mut Pool<T0, T1>,i128::I128,i32::I32,i32::I32,&Clock)

public fun update_pool_url<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,String)

fun update_swap_result(&mut SwapResult,u64,u64,u64,u64,u64,u64)

public fun update_unstaked_liquidity_fee_rate<T0, T1>(&config::GlobalConfig,&mut Pool<T0, T1>,u64)

public fun url<T0, T1>(&Pool<T0, T1>): String

fun validate_pool_position<T0, T1>(&Pool<T0, T1>,&position::Position)