# Contract Modules

### Table of Contents

1. Pool Factory Module
2. Pool Module
3. Position Manager Module
4. Swap Router Module
5. Reward Manager Module
6. Pool Fetcher Module
7. Position NFT Module
8. Partner Module

***

### Pool Factory Module

The Pool Factory is responsible for managing liquidity pool creation, configuration, and access control.

#### Pool Creation Functions

**`deploy_pool_and_mint`**

```move
public entry fun deploy_pool_and_mint<CoinTypeA, CoinTypeB, FeeType>(
    pool_config: &mut PoolConfig,
    feeType: &Fee<FeeType>,
    sqrt_price: u128,
    positions: &mut Positions,
    coins_a: vector<Coin<CoinTypeA>>,
    coins_b: vector<Coin<CoinTypeB>>,
    tick_lower_index: u32,
    tick_lower_index_is_neg: bool,
    tick_upper_index: u32,
    tick_upper_index_is_neg: bool,
    amount_a_desired: u64,
    amount_b_desired: u64,
    amount_a_min: u64,
    amount_b_min: u64,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Creates a new liquidity pool and simultaneously mints initial liquidity position\
**Parameters**:

* `pool_config`: Pool configuration object
* `feeType`: Fee type configuration
* `sqrt_price`: Square root of initial price
* `positions`: Position manager
* `coins_a/coins_b`: Tokens to be added
* `tick_lower/upper_index`: Price range bounds
* `amount_a/b_desired`: Desired token amounts to add
* `amount_a/b_min`: Minimum token amounts to add
* `recipient`: Recipient address
* `deadline`: Transaction deadline

**`deploy_pool_and_mint_with_return_`**

```move
public fun deploy_pool_and_mint_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    // Same parameters as above function
): (TurbosPositionNFT, Coin<CoinTypeA>, Coin<CoinTypeB>, ID)
```

**Function**: Creates pool and mints liquidity, returns NFT and remaining tokens\
**Returns**: Position NFT, remaining coin A, remaining coin B, pool ID

**`deploy_pool`**

```move
public entry fun deploy_pool<CoinTypeA, CoinTypeB, FeeType>(
    pool_config: &mut PoolConfig,
    feeType: &Fee<FeeType>,
    sqrt_price: u128,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Only creates a new liquidity pool without adding liquidity

**`get_pool_id`**

```move
public fun get_pool_id<CoinTypeA, CoinTypeB, FeeType>(
    pool_config: &mut PoolConfig,
): Option<ID>
```

**Function**: Gets the pool ID for specified token pair and fee type\
**Returns**: Pool ID (if exists)

***

### Pool Module

The Pool module is the core of the CLMM protocol, responsible for handling liquidity, swaps, and price calculations.

#### Version Management Functions

**`version`**

```move
public fun version(versioned: &Versioned): u64
```

**Function**: Gets current protocol version number

**`check_version`**

```move
public fun check_version(versioned: &Versioned)
```

**Function**: Checks if protocol version matches

#### Flash Loan Functions

**`flash_swap`**

```move
public fun flash_swap<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    recipient: address,
    a_to_b: bool,
    amount_specified: u128,
    amount_specified_is_input: bool,
    sqrt_price_limit: u128,
    clock: &Clock,
    ctx: &mut TxContext
): FlashSwapReceipt<CoinTypeA, CoinTypeB>
```

**Function**: Executes flash swap, returns receipt that needs to be repaid

**`flash_swap_partner`**

```move
public fun flash_swap_partner<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    partner: &Partner,
    recipient: address,
    a_to_b: bool,
    amount_specified: u128,
    amount_specified_is_input: bool,
    sqrt_price_limit: u128,
    clock: &Clock,
    ctx: &mut TxContext
): FlashSwapReceiptPartner<CoinTypeA, CoinTypeB>
```

**Function**: Executes flash swap through partner

**`repay_flash_swap`**

```move
public fun repay_flash_swap<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    coin_a: Coin<CoinTypeA>,
    coin_b: Coin<CoinTypeB>,
    receipt: FlashSwapReceipt<CoinTypeA, CoinTypeB>,
    ctx: &mut TxContext
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Repays flash swap, returns remaining tokens

**`repay_flash_swap_partner`**

```move
public fun repay_flash_swap_partner<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    partner: &mut Partner,
    coin_a: Coin<CoinTypeA>,
    coin_b: Coin<CoinTypeB>,
    receipt: FlashSwapReceiptPartner<CoinTypeA, CoinTypeB>,
    ctx: &mut TxContext
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Repays partner flash swap

**`flash_swap_pay_amount`**

```move
public fun flash_swap_pay_amount<CoinTypeA, CoinTypeB>(
    swap_receipt: &FlashSwapReceiptPartner<CoinTypeA, CoinTypeB>
): u64
```

**Function**: Gets the amount that needs to be paid for flash swap

#### Tick Related Functions

**`next_initialized_tick_within_one_word`**

```move
public fun next_initialized_tick_within_one_word<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    tick: I32,
    lte: bool,
): (I32, bool)
```

**Function**: Finds next initialized tick within one word range

**`position_tick`**

```move
public fun position_tick(tick: I32): (I32, u8)
```

**Function**: Calculates word position and bit index for position tick

**`get_tick`**

```move
public fun get_tick<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    tick_index: I32,
): TickInfo
```

**Function**: Gets information for specified tick

#### Position Related Functions

**`get_position`**

```move
public fun get_position<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    position_key: ID,
): PositionInfo
```

**Function**: Gets position information

**`check_position_exists`**

```move
public fun check_position_exists<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    position_key: ID,
): bool
```

**Function**: Checks if position exists

**`get_position_key_fix`**

```move
public fun get_position_key_fix<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    tick_lower_index: I32,
    tick_upper_index: I32,
    user_address: address,
): ID
```

**Function**: Generates unique identifier for position

**`get_position_key`**

```move
public fun get_position_key(
    tick_lower_index: I32,
    tick_upper_index: I32,
    user_address: address,
): ID
```

**Function**: Generates position key from parameters

#### Pool State Query Functions

**`get_pool_fee`**

```move
public fun get_pool_fee<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>
): u32
```

**Function**: Gets pool fee rate

**`get_pool_sqrt_price`**

```move
public fun get_pool_sqrt_price<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>
): u128
```

**Function**: Gets pool's current sqrt price

**`get_pool_current_index`**

```move
public fun get_pool_current_index<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>
): I32
```

**Function**: Gets pool's current tick index

**`get_pool_liquidity`**

```move
public fun get_pool_liquidity<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>
): u128
```

**Function**: Gets pool's current liquidity

**`get_pool_balance`**

```move
public fun get_pool_balance<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>
): (u64, u64)
```

**Function**: Gets pool's token balances

**`get_pool_info`**

```move
public fun get_pool_info<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>
): PoolInfo
```

**Function**: Gets complete pool information

#### Fee and Reward Query Functions

**`get_pool_fee_growth_global`**

```move
public fun get_pool_fee_growth_global<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>
): (u128, u128)
```

**Function**: Gets global fee growth

**`get_position_fee_growth_inside_a`**

```move
public fun get_position_fee_growth_inside_a<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    position_key: ID,
): u128
```

**Function**: Gets position's internal fee growth for token A

**`get_position_base_info`**

```move
public fun get_position_base_info<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    position_key: ID,
): (I32, I32, u128)
```

**Function**: Gets position's basic info (tick range and liquidity)

**`get_reward_info`**

```move
public fun get_reward_info<CoinTypeA, CoinTypeB, FeeType>(
    pool: &Pool<CoinTypeA, CoinTypeB, FeeType>,
    reward_index: u64,
): PoolRewardInfo
```

**Function**: Gets reward information

***

### Position Manager Module

The Position Manager is responsible for managing liquidity position minting, burning, and liquidity adjustments.

#### Liquidity Minting Functions

**`mint`**

```move
public entry fun mint<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    coins_a: vector<Coin<CoinTypeA>>,
    coins_b: vector<Coin<CoinTypeB>>,
    tick_lower_index: u32,
    tick_lower_index_is_neg: bool,
    tick_upper_index: u32,
    tick_upper_index_is_neg: bool,
    amount_a_desired: u64,
    amount_b_desired: u64,
    amount_a_min: u64,
    amount_b_min: u64,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Mints new liquidity position

**`mint_with_return_`**

```move
public fun mint_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    // Same parameters as above function
): (TurbosPositionNFT, Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Mints liquidity position and returns NFT and remaining tokens

#### Liquidity Burning Functions

**`burn`**

```move
public entry fun burn<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: TurbosPositionNFT,
    amount_a_min: u64,
    amount_b_min: u64,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Burns liquidity position and collects tokens

#### Liquidity Adjustment Functions

**`increase_liquidity`**

```move
public entry fun increase_liquidity<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: &TurbosPositionNFT,
    coins_a: vector<Coin<CoinTypeA>>,
    coins_b: vector<Coin<CoinTypeB>>,
    amount_a_desired: u64,
    amount_b_desired: u64,
    amount_a_min: u64,
    amount_b_min: u64,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Increases position's liquidity

**`increase_liquidity_with_return_`**

```move
public fun increase_liquidity_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    // Same parameters as above function
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Increases liquidity and returns remaining tokens

**`decrease_liquidity`**

```move
public entry fun decrease_liquidity<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: &TurbosPositionNFT,
    liquidity: u128,
    amount_a_min: u64,
    amount_b_min: u64,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Decreases position's liquidity

**`decrease_liquidity_with_return_`**

```move
public fun decrease_liquidity_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    // Same parameters as above function
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Decreases liquidity and returns tokens

#### Fee Collection Functions

**`collect`**

```move
public entry fun collect<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: &TurbosPositionNFT,
    amount_a_max: u64,
    amount_b_max: u64,
    recipient: address,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Collects trading fees generated by position

**`collect_with_return_`**

```move
public fun collect_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    // Same parameters as above function
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Collects fees and returns coin objects

#### Reward Collection Functions

**`collect_reward`**

```move
public entry fun collect_reward<CoinTypeA, CoinTypeB, FeeType, RewardCoin>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: &TurbosPositionNFT,
    vault: &mut PoolRewardVault<RewardCoin>,
    reward_index: u64,
    amount_requested: u64,
    recipient: address,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Collects position's reward tokens

**`collect_reward_with_return_`**

```move
public fun collect_reward_with_return_<CoinTypeA, CoinTypeB, FeeType, RewardCoin>(
    // Same parameters as above function
): Coin<RewardCoin>
```

**Function**: Collects rewards and returns coin object

#### NFT Management Functions

**`burn_position_nft_with_return_`**

```move
public fun burn_position_nft_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: TurbosPositionNFT,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Burns position NFT and returns tokens

**`burn_nft_collect_reward_with_return_`**

```move
public fun burn_nft_collect_reward_with_return_<CoinTypeA, CoinTypeB, FeeType, RewardCoin>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: TurbosPositionNFT,
    vault: &mut PoolRewardVault<RewardCoin>,
    reward_index: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
): (Coin<CoinTypeA>, Coin<CoinTypeB>, Coin<RewardCoin>)
```

**Function**: Burns NFT and collects rewards

**`burn_nft_collect_fee_with_return_`**

```move
public fun burn_nft_collect_fee_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    positions: &mut Positions,
    nft: TurbosPositionNFT,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Burns NFT and collects fees

#### Query Functions

**`get_position_info`**

```move
public fun get_position_info(
    positions: &Positions,
    nft: &TurbosPositionNFT
): (I32, I32, u128, u64, u64, vector<PositionRewardInfo>)
```

**Function**: Gets detailed position information

**`get_nft_minted`**

```move
public fun get_nft_minted(positions: &Positions): u64
```

**Function**: Gets number of minted NFTs

**`burn_nft_directly`**

```move
public entry fun burn_nft_directly(
    positions: &mut Positions,
    nft: TurbosPositionNFT,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Directly burns empty position NFT

***

### Swap Router Module

The Swap Router provides token swapping functionality, supporting single-step and multi-step swaps.

#### Single-Step Swap Functions

**`swap_a_b`**

```move
public entry fun swap_a_b<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    coins_a: vector<Coin<CoinTypeA>>, 
    amount: u64,
    amount_threshold: u64,
    sqrt_price_limit: u128,
    is_exact_in: bool,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Swaps token A for token B

**`swap_a_b_with_return_`**

```move
public fun swap_a_b_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    // Same parameters as above function
): (Coin<CoinTypeB>, Coin<CoinTypeA>)
```

**Function**: Swaps tokens and returns result tokens

**`swap_b_a`**

```move
public entry fun swap_b_a<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    coins_b: vector<Coin<CoinTypeB>>, 
    amount: u64,
    amount_threshold: u64,
    sqrt_price_limit: u128,
    is_exact_in: bool,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Swaps token B for token A

**`swap_b_a_with_return_`**

```move
public fun swap_b_a_with_return_<CoinTypeA, CoinTypeB, FeeType>(
    // Same parameters as above function
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Swaps tokens and returns result tokens

#### Partner Swap Functions

**`swap_with_partner`**

```move
public fun swap_with_partner<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    partner: &mut Partner,
    coins: vector<Coin<CoinTypeA>>,
    a_to_b: bool,
    amount: u64,
    amount_threshold: u64,
    sqrt_price_limit: u128,
    is_exact_in: bool,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
): (Coin<CoinTypeA>, Coin<CoinTypeB>)
```

**Function**: Swaps through partner with fee sharing

#### Multi-Step Swap Functions

**`swap_a_b_b_c`**

```move
public entry fun swap_a_b_b_c<CoinTypeA, FeeTypeA, CoinTypeB, FeeTypeB, CoinTypeC>(
    pool_a: &mut Pool<CoinTypeA, CoinTypeB, FeeTypeA>,
    pool_b: &mut Pool<CoinTypeB, CoinTypeC, FeeTypeB>,
    coins_a: vector<Coin<CoinTypeA>>,
    amount: u64,
    amount_threshold: u64,
    sqrt_price_limit_a: u128,
    sqrt_price_limit_b: u128,
    is_exact_in: bool,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Two-step swap: A → B → C

**`swap_a_b_b_c_with_return_`**

```move
public fun swap_a_b_b_c_with_return_<CoinTypeA, FeeTypeA, CoinTypeB, FeeTypeB, CoinTypeC>(
    // Same parameters as above function
): (Coin<CoinTypeC>, Coin<CoinTypeA>)
```

**Function**: Two-step swap and returns result tokens

**`swap_a_b_c_b`**

```move
public entry fun swap_a_b_c_b<CoinTypeA, FeeTypeA, CoinTypeB, FeeTypeB, CoinTypeC>(
    pool_a: &mut Pool<CoinTypeA, CoinTypeB, FeeTypeA>,
    pool_b: &mut Pool<CoinTypeC, CoinTypeB, FeeTypeB>,
    coins_a: vector<Coin<CoinTypeA>>,
    amount: u64,
    amount_threshold: u64,
    sqrt_price_limit_a: u128,
    sqrt_price_limit_b: u128,
    is_exact_in: bool,
    recipient: address,
    deadline: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Two-step swap: A → B → C (through different pools)

***

### Reward Manager Module

The Reward Manager is responsible for managing liquidity mining reward systems.

#### Reward Initialization Functions

**`init_reward_v2`**

```move
public entry fun init_reward_v2<CoinTypeA, CoinTypeB, FeeType, RewardCoin>(
    acl_config: &AclConfig,
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    reward_index: u64,
    manager: address,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Initializes pool reward system (requires reward manager role)

**`reset_reward_v2`**

```move
public entry fun reset_reward_v2<CoinTypeA, CoinTypeB, FeeType, RewardCoin>(
    acl_config: &AclConfig,
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    reward_index: u64,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Resets reward configuration

#### Reward Management Functions

**`add_reward`**

```move
public entry fun add_reward<CoinTypeA, CoinTypeB, FeeType, RewardCoin>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    vault: &mut PoolRewardVault<RewardCoin>,
    reward_index: u64,
    coins: vector<Coin<RewardCoin>>,
    amount: u64,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Adds reward tokens to reward pool

**`remove_reward`**

```move
public entry fun remove_reward<CoinTypeA, CoinTypeB, FeeType, RewardCoin>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    vault: &mut PoolRewardVault<RewardCoin>,
    reward_index: u64,
    amount: u64,
    recipient: address,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Removes reward tokens from reward pool

**`set_reward_emissions_per_second`**

```move
public entry fun set_reward_emissions_per_second<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    reward_index: u64,
    emissions_per_second: u128,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext
)
```

**Function**: Sets reward emission rate per second

***

### Pool Fetcher Module

The Pool Fetcher provides pool state querying and calculation functionality.

#### Swap Calculation Functions

**`compute_swap_result`**

```move
public entry fun compute_swap_result<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    a_to_b: bool,
    amount_specified: u128,
    amount_specified_is_input: bool,
    sqrt_price_limit: u128,
    clock: &Clock,
    versioned: &Versioned,
    ctx: &mut TxContext,
): ComputeSwapState
```

**Function**: Calculates swap result without executing actual swap

#### Tick Data Retrieval Functions

**`fetch_ticks`**

```move
public entry fun fetch_ticks<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    start: vector<u32>,
    start_index_is_neg: bool,
    limit: u64,
    versioned: &Versioned,
)
```

**Function**: Batch retrieves tick data, returns results through events

**`fetch_ticks_for_testing`**

```move
public fun fetch_ticks_for_testing<CoinTypeA, CoinTypeB, FeeType>(
    pool: &mut Pool<CoinTypeA, CoinTypeB, FeeType>,
    start: vector<u32>,
    start_index_is_neg: bool,
    limit: u64,
    versioned: &Versioned,
): (vector<TickInfo>, Option<I32>)
```

**Function**: Testing function for tick data retrieval, returns results directly

***

### Position NFT Module

The Position NFT module manages NFTs representing liquidity positions.

#### NFT Information Query Functions

**`pool_id`**

```move
public fun pool_id(nft: &TurbosPositionNFT): ID
```

**Function**: Gets pool ID corresponding to NFT

**`position_id`**

```move
public fun position_id(nft: &TurbosPositionNFT): ID
```

**Function**: Gets position ID corresponding to NFT

***

### Partner Module

The Partner module manages the partner system and fee sharing.

#### Partner Management Functions

**`create_partner`**

```move
public entry fun create_partner(
    _: &PartnerAdminCap,
    partners: &mut Partners,
    name: String,
    ref_fee_rate: u64,
    start_time: u64,
    end_time: u64,
    recipient: address,
    clock: &Clock,
    ctx: &mut TxContext
)
```

**Function**: Creates new partner

**`update_ref_fee_rate`**

```move
public entry fun update_ref_fee_rate(
    _: &PartnerAdminCap,
    partner: &mut Partner,
    ref_fee_rate: u64,
    clock: &Clock,
    versioned: &Versioned,
)
```

**Function**: Updates partner's fee sharing ratio

**`update_time_range`**

```move
public entry fun update_time_range(
    _: &PartnerAdminCap,
    partner: &mut Partner,
    start_time: u64,
    end_time: u64,
    clock: &Clock,
    versioned: &Versioned,
)
```

**Function**: Updates partner's valid time range

#### Fee Collection Functions

**`claim_ref_fee`**

```move
public entry fun claim_ref_fee<CoinType>(
    partner_cap: &PartnerCap,
    partner: &mut Partner,
    amount: u64,
    recipient: address,
    ctx: &mut TxContext
)
```

**Function**: Claims partner fee sharing

**`claim_ref_fee_with_return_`**

```move
public fun claim_ref_fee_with_return_<CoinType>(
    partner_cap: &PartnerCap,
    partner: &mut Partner,
    amount: u64,
    ctx: &mut TxContext
): Coin<CoinType>
```

**Function**: Claims fee sharing and returns coin object

#### Query Functions

**`get_ref_fee_rate`**

```move
public fun get_ref_fee_rate(partner: &Partner): u64
```

**Function**: Gets partner's fee sharing ratio

**`check_partner_valid`**

```move
public fun check_partner_valid(partner: &Partner, clock: &Clock): bool
```

**Function**: Checks if partner is within valid period

**`get_claimable_balance`**

```move
public fun get_claimable_balance<CoinType>(partner: &Partner): u64
```

**Function**: Gets claimable fee balance

### Usage Recommendations

1. **Version Check**: All pool operation functions check protocol version to ensure compatibility
2. **Time Limits**: Most transaction functions include `deadline` parameter to prevent malicious exploitation during network congestion
3. **Slippage Protection**: Swap and liquidity operations include min/max amount parameters for slippage protection
4. **Permission Management**: Sensitive operations require appropriate admin permissions, controlled through ACL system
5. **Event Monitoring**: Important operations emit events for frontend and analytics tools to monitor

This documentation covers all public interfaces of the Turbos CLMM protocol, providing developers with a complete integration guide.