defituna_core/quote/

tuna_spot_position.rs

#![allow(clippy::collapsible_else_if)]
#![allow(clippy::too_many_arguments)]

#[cfg(feature = "wasm")]
use fusionamm_macros::wasm_expose;
#[cfg(feature = "wasm")]
use serde::Serialize;
#[cfg(feature = "wasm")]
use serde_wasm_bindgen::Serializer;
#[cfg(feature = "wasm")]
use wasm_bindgen::prelude::wasm_bindgen;
#[cfg(feature = "wasm")]
use wasm_bindgen::JsValue;

use crate::{
    CoreError, HUNDRED_PERCENT, INVALID_ARGUMENTS, JUPITER_QUOTE_REQUEST_ERROR, JUPITER_SWAP_INSTRUCTIONS_REQUEST_ERROR, TICK_ARRAYS_NOT_PROVIDED,
    TOKEN_A, TOKEN_B,
};
use fusionamm_core::{
    sqrt_price_to_price, swap_quote_by_input_token, swap_quote_by_output_token, try_get_max_amount_with_slippage_tolerance,
    try_get_min_amount_with_slippage_tolerance, try_mul_div, FusionPoolFacade, TickArrays, TokenPair,
};
use jup_ag::{PrioritizationFeeLamports, QuoteConfig, SwapMode, SwapRequest};
use libm::{ceil, round};
use solana_instruction::AccountMeta;
use solana_pubkey::Pubkey;

pub const DEFAULT_SLIPPAGE_TOLERANCE_BPS: u16 = 100;

#[cfg_attr(feature = "wasm", wasm_expose)]
pub struct SwapInstruction {
    pub data: Vec<u8>,
    pub accounts: Vec<AccountMeta>,
    pub address_lookup_table_addresses: Vec<Pubkey>,
}

#[cfg_attr(feature = "wasm", wasm_expose)]
pub struct IncreaseSpotPositionQuoteResult {
    /** Required collateral amount */
    pub collateral: u64,
    /** Required amount to borrow */
    pub borrow: u64,
    /** Estimated position size in the position token. */
    pub estimated_amount: u64,
    /** Swap input amount. */
    pub swap_input_amount: u64,
    /** Minimum swap output amount according to the provided slippage. */
    pub min_swap_output_amount: u64,
    /** Protocol fee in token A */
    pub protocol_fee_a: u64,
    /** Protocol fee in token B */
    pub protocol_fee_b: u64,
    /** Price impact in percents (100% = 1.0) */
    pub price_impact: f64,
    /** Optional jupiter swap instruction data and accounts. */
    pub jupiter_swap_ix: Option<SwapInstruction>,
}

/// Spot position increase quote
///
/// # Parameters
/// - `increase_amount`: Position total size in the collateral_token.
/// - `collateral_token`: Collateral token.
/// - `position_token`: Token of the position.
/// - `leverage`: Leverage (1.0 or higher).
/// - `slippage_tolerance_bps`: An optional slippage tolerance in basis points. Defaults to the global slippage tolerance if not provided.
/// - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `mint_a`: Token A mint address
/// - `mint_b`: Token B mint address
/// - `fusion_pool`: Fusion pool.
/// - `tick_arrays`: Optional five tick arrays around the current pool price. If not provided, the quote will be calculated using the Jupiter Aggregator.
///
/// # Returns
/// - `IncreaseSpotPositionQuoteResult`: quote result
pub async fn get_increase_spot_position_quote(
    increase_amount: u64,
    collateral_token: u8,
    position_token: u8,
    leverage: f64,
    slippage_tolerance_bps: Option<u16>,
    protocol_fee_rate: u16,
    protocol_fee_rate_on_collateral: u16,
    mint_a: Pubkey,
    mint_b: Pubkey,
    fusion_pool: FusionPoolFacade,
    tick_arrays: Option<TickArrays>,
) -> Result<IncreaseSpotPositionQuoteResult, CoreError> {
    if collateral_token > TOKEN_B || position_token > TOKEN_B {
        return Err(INVALID_ARGUMENTS.into());
    }

    if leverage < 1.0 {
        return Err(INVALID_ARGUMENTS.into());
    }

    let borrow: u64;
    let mut collateral: u64;
    let mut estimated_amount: u64 = 0;
    let mut swap_input_amount: u64;
    let mut min_swap_output_amount: u64 = 0;
    let mut price_impact: f64 = 0.0;
    let mut jupiter_swap_ix: Option<SwapInstruction> = None;

    let price = sqrt_price_to_price(fusion_pool.sqrt_price.into(), 1, 1);
    let slippage_tolerance_bps = slippage_tolerance_bps.unwrap_or(DEFAULT_SLIPPAGE_TOLERANCE_BPS);

    let borrowed_token = if position_token == TOKEN_A { TOKEN_B } else { TOKEN_A };
    let swap_input_token_is_a = borrowed_token == TOKEN_A;

    if borrowed_token == collateral_token {
        borrow = ceil((increase_amount as f64 * (leverage - 1.0)) / leverage) as u64;
        collateral = increase_amount - apply_swap_fee(apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?, fusion_pool.fee_rate, false)?;
        collateral = reverse_apply_swap_fee(collateral, fusion_pool.fee_rate, false)?;
        collateral = reverse_apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;

        swap_input_amount = collateral + borrow;
    } else {
        let position_to_borrowed_token_price = if collateral_token == TOKEN_A { price } else { 1.0 / price };
        let borrow_in_position_token = ceil((increase_amount as f64 * (leverage - 1.0)) / leverage);

        borrow = ceil(borrow_in_position_token * position_to_borrowed_token_price) as u64;

        let borrow_in_position_token_with_fees_applied =
            apply_swap_fee(apply_tuna_protocol_fee(borrow_in_position_token as u64, protocol_fee_rate, false)?, fusion_pool.fee_rate, false)?;

        collateral = increase_amount - borrow_in_position_token_with_fees_applied;
        collateral = reverse_apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;

        swap_input_amount = borrow;
    }

    let protocol_fee =
        calculate_tuna_protocol_fee(collateral_token, borrowed_token, collateral, borrow, protocol_fee_rate_on_collateral, protocol_fee_rate);

    swap_input_amount -= if swap_input_token_is_a { protocol_fee.a } else { protocol_fee.b };

    if position_token == collateral_token {
        estimated_amount = collateral - if collateral_token == TOKEN_A { protocol_fee.a } else { protocol_fee.b };
    }

    if swap_input_amount > 0 {
        if let Some(tick_arrays) = tick_arrays {
            let quote = swap_quote_by_input_token(swap_input_amount, swap_input_token_is_a, 0, fusion_pool, tick_arrays, None, None)?;
            estimated_amount += quote.token_est_out;
            min_swap_output_amount = try_get_min_amount_with_slippage_tolerance(quote.token_est_out, slippage_tolerance_bps)?;
            let new_price = sqrt_price_to_price(quote.next_sqrt_price.into(), 1, 1);
            price_impact = (new_price / price - 1.0).abs();
        } else {
            let (input_mint, output_mint) = if swap_input_token_is_a { (mint_a, mint_b) } else { (mint_b, mint_a) };

            let quote = jupiter_swap_quote(input_mint, output_mint, swap_input_amount, Some(slippage_tolerance_bps as u64)).await?;

            estimated_amount += quote.out_amount;
            price_impact = quote.price_impact_pct;
            min_swap_output_amount = quote.other_amount_threshold;
            jupiter_swap_ix = Some(SwapInstruction {
                data: quote.instruction.data,
                accounts: quote.instruction.accounts,
                address_lookup_table_addresses: quote.instruction.address_lookup_table_addresses,
            });
        }
    }

    Ok(IncreaseSpotPositionQuoteResult {
        collateral,
        borrow,
        estimated_amount,
        swap_input_amount,
        min_swap_output_amount,
        protocol_fee_a: protocol_fee.a,
        protocol_fee_b: protocol_fee.b,
        price_impact,
        jupiter_swap_ix,
    })
}

/// Spot position increase quote
///
/// # Parameters
/// - `increase_amount`: Position total size in the collateral_token.
/// - `collateral_token`: Collateral token.
/// - `position_token`: Token of the position.
/// - `leverage`: Leverage (1.0 or higher).
/// - `slippage_tolerance_bps`: An optional slippage tolerance in basis points. Defaults to the global slippage tolerance if not provided.
/// - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `mint_a`: Token A mint address
/// - `mint_b`: Token B mint address
/// - `fusion_pool`: Fusion pool.
/// - `tick_arrays`: Optional five tick arrays around the current pool price. If not provided, the quote will be calculated using the Jupiter Aggregator.
///
/// # Returns
/// - `IncreaseSpotPositionQuoteResult`: quote result
#[cfg(feature = "wasm")]
#[wasm_bindgen(js_name = "getIncreaseSpotPositionQuote", skip_jsdoc)]
pub async fn wasm_get_increase_spot_position_quote(
    increase_amount: u64,
    collateral_token: u8,
    position_token: u8,
    leverage: f64,
    slippage_tolerance_bps: Option<u16>,
    protocol_fee_rate: u16,
    protocol_fee_rate_on_collateral: u16,
    mint_a: Pubkey,
    mint_b: Pubkey,
    fusion_pool: FusionPoolFacade,
    tick_arrays: Option<TickArrays>,
) -> Result<JsValue, JsValue> {
    let result = get_increase_spot_position_quote(
        increase_amount,
        collateral_token,
        position_token,
        leverage,
        slippage_tolerance_bps,
        protocol_fee_rate,
        protocol_fee_rate_on_collateral,
        mint_a,
        mint_b,
        fusion_pool,
        tick_arrays,
    )
    .await
    .map_err(|e| JsValue::from_str(e))?;

    let serializer = Serializer::new().serialize_maps_as_objects(true);
    let js_value = result.serialize(&serializer).unwrap();

    Ok(js_value)
}

#[cfg_attr(feature = "wasm", wasm_expose)]
pub struct DecreaseSpotPositionQuoteResult {
    /** Position decrease percentage */
    pub decrease_percent: u32,
    /** Collateral token of the new position */
    pub collateral_token: u8,
    /** Token of the new position */
    pub position_token: u8,
    /** Required additional collateral amount */
    pub collateral: u64,
    /** Required amount to borrow */
    pub borrow: u64,
    /** The maximum acceptable swap input amount for position decrease according to the provided slippage
     * (if collateral_token == position_token) OR the minimum swap output amount (if collateral_token != position_token).
     */
    pub decrease_acceptable_swap_amount: u64,
    /** The minimum swap output amount for position increase according to the provided slippage. */
    pub increase_min_swap_output_amount: u64,
    /** Estimated total amount of the new position */
    pub estimated_amount: u64,
    /** Protocol fee in token A */
    pub protocol_fee_a: u64,
    /** Protocol fee in token B */
    pub protocol_fee_b: u64,
    /** Price impact in percents (100% = 1.0) */
    pub price_impact: f64,
    /** Optional jupiter swap instruction data and accounts. */
    pub jupiter_swap_ix: Option<SwapInstruction>,
}

/// Spot position decrease quote
///
/// # Parameters
/// - `decrease_amount`: Position total decrease size in the collateral_token.
/// - `collateral_token`: Collateral token.
/// - `leverage`: Leverage (1.0 or higher).
/// - `reduce_only`: Only allow reducing the existing position.
/// - `slippage_tolerance_bps`: An optional slippage tolerance in basis points. Defaults to the global slippage tolerance if not provided.
/// - `position_token`: Token of the existing position.
/// - `position_amount`: Existing position amount in the position_token.
/// - `position_debt`: Existing position debt in the token opposite to the position_token.
/// - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `fusion_pool`: Fusion pool.
/// - `tick_arrays`: Optional five tick arrays around the current pool price. If not provided, the quote will be calculated using the Jupiter Aggregator.
///
/// # Returns
/// - `DecreaseSpotPositionQuoteResult`: quote result
pub async fn get_decrease_spot_position_quote(
    decrease_amount: u64,
    collateral_token: u8,
    leverage: f64,
    reduce_only: bool,
    slippage_tolerance_bps: Option<u16>,
    position_token: u8,
    position_amount: u64,
    position_debt: u64,
    protocol_fee_rate: u16,
    protocol_fee_rate_on_collateral: u16,
    mint_a: Pubkey,
    mint_b: Pubkey,
    fusion_pool: FusionPoolFacade,
    tick_arrays: Option<TickArrays>,
) -> Result<DecreaseSpotPositionQuoteResult, CoreError> {
    if collateral_token > TOKEN_B || position_token > TOKEN_B {
        return Err(INVALID_ARGUMENTS.into());
    }

    if leverage < 1.0 {
        return Err(INVALID_ARGUMENTS.into());
    }

    let price = sqrt_price_to_price(fusion_pool.sqrt_price.into(), 1, 1);
    let position_to_borrowed_token_price = if position_token == TOKEN_A { price } else { 1.0 / price };
    let borrowed_token = if position_token == TOKEN_A { TOKEN_B } else { TOKEN_A };
    let slippage_tolerance_bps = slippage_tolerance_bps.unwrap_or(DEFAULT_SLIPPAGE_TOLERANCE_BPS);

    let mut collateral = 0;
    let mut borrow = 0;
    let estimated_amount: u64;
    let mut new_position_token = position_token;
    let mut increase_min_swap_output_amount: u64 = 0;
    let mut decrease_acceptable_swap_amount: u64 = 0;
    let mut price_impact = 0.0;
    let mut jupiter_swap_ix: Option<SwapInstruction> = None;

    let mut decrease_amount_in_position_token = if collateral_token == position_token {
        decrease_amount
    } else {
        round(decrease_amount as f64 / position_to_borrowed_token_price) as u64
    };

    if reduce_only && decrease_amount_in_position_token > position_amount {
        decrease_amount_in_position_token = position_amount;
    }

    let decrease_percent = ((decrease_amount_in_position_token * HUNDRED_PERCENT as u64 / position_amount) as u32).min(HUNDRED_PERCENT);

    if decrease_amount_in_position_token <= position_amount {
        estimated_amount = position_amount * (HUNDRED_PERCENT - decrease_percent) as u64 / HUNDRED_PERCENT as u64;

        if let Some(tick_arrays) = tick_arrays {
            let mut next_sqrt_price = fusion_pool.sqrt_price;

            if collateral_token == position_token {
                if position_debt > 0 {
                    let amount_out = position_debt * decrease_percent as u64 / HUNDRED_PERCENT as u64;
                    let swap = swap_quote_by_output_token(amount_out, borrowed_token == TOKEN_A, 0, fusion_pool, tick_arrays, None, None)?;
                    next_sqrt_price = swap.next_sqrt_price;
                    decrease_acceptable_swap_amount = try_get_max_amount_with_slippage_tolerance(swap.token_est_in, slippage_tolerance_bps)?;
                }
            } else {
                let amount_in = position_amount - estimated_amount;
                let swap = swap_quote_by_input_token(amount_in, position_token == TOKEN_A, 0, fusion_pool, tick_arrays, None, None)?;
                next_sqrt_price = swap.next_sqrt_price;
                decrease_acceptable_swap_amount = try_get_min_amount_with_slippage_tolerance(swap.token_est_out, slippage_tolerance_bps)?;
            }

            let new_price = sqrt_price_to_price(next_sqrt_price.into(), 1, 1);
            price_impact = (new_price / price - 1.0).abs();
        } else {
            let (input_mint, output_mint) = if position_token == TOKEN_A { (mint_a, mint_b) } else { (mint_b, mint_a) };

            let amount_in = if collateral_token == position_token {
                if position_debt > 0 {
                    let mut amount_in = if position_token == TOKEN_A {
                        (position_debt as f64 / price) as u64
                    } else {
                        (position_debt as f64 * price) as u64
                    };
                    amount_in = try_get_max_amount_with_slippage_tolerance(amount_in, slippage_tolerance_bps)?;
                    amount_in.min(position_amount)
                } else {
                    0
                }
            } else {
                position_amount - estimated_amount
            };

            if amount_in > 0 {
                let quote = jupiter_swap_quote(input_mint, output_mint, amount_in, Some(slippage_tolerance_bps as u64)).await?;

                price_impact = quote.price_impact_pct;
                decrease_acceptable_swap_amount = quote.other_amount_threshold;
                jupiter_swap_ix = Some(SwapInstruction {
                    data: quote.instruction.data,
                    accounts: quote.instruction.accounts,
                    address_lookup_table_addresses: quote.instruction.address_lookup_table_addresses,
                });
            }
        }
    } else {
        let mut next_sqrt_price = fusion_pool.sqrt_price;
        new_position_token = if position_token == TOKEN_A { TOKEN_B } else { TOKEN_A };
        let increase_amount = decrease_amount_in_position_token - position_amount;
        let mut increase_swap_output_amount: u64 = 0;

        let tick_arrays = tick_arrays.ok_or(TICK_ARRAYS_NOT_PROVIDED)?;

        if position_token == collateral_token {
            // Example:
            // collateral_token: A
            // position_token: A
            // position_debt: B
            // new_position_token: B
            // newBorrowedToken: A

            // A
            borrow = ((increase_amount as f64 * (leverage - 1.0)) / leverage) as u64;
            let borrow_with_fees_applied = apply_swap_fee(apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?, fusion_pool.fee_rate, false)?;

            collateral = increase_amount - borrow_with_fees_applied;

            // Decrease swap: A->B
            let mut amount_in = 0;
            if position_debt > 0 {
                let swap =
                    swap_quote_by_output_token(position_debt, borrowed_token == TOKEN_A, 0, fusion_pool, tick_arrays.clone().into(), None, None)?;
                amount_in = swap.token_est_in;
                decrease_acceptable_swap_amount = try_get_max_amount_with_slippage_tolerance(amount_in, slippage_tolerance_bps)?;
            }

            // Decrease+Increase swap: A->B
            amount_in += collateral + apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
            if amount_in > 0 {
                let swap = swap_quote_by_input_token(amount_in, position_token == TOKEN_A, 0, fusion_pool, tick_arrays, None, None)?;
                next_sqrt_price = swap.next_sqrt_price;
                increase_swap_output_amount = swap.token_est_out.saturating_sub(position_debt);
            }

            // B
            estimated_amount = increase_swap_output_amount;
        } else {
            // Example:
            // collateral_token: B
            // position_token: A
            // new_position_token: B
            // newBorrowedToken: A

            // Decrease swap A->B
            let swap = swap_quote_by_input_token(position_amount, position_token == TOKEN_A, 0, fusion_pool, tick_arrays.clone().into(), None, None)?;
            let decrease_amount_out = swap.token_est_out;
            decrease_acceptable_swap_amount = try_get_min_amount_with_slippage_tolerance(swap.token_est_out, slippage_tolerance_bps)?;

            borrow = ((increase_amount as f64 * (leverage - 1.0)) / leverage) as u64;
            let borrow_with_fees_applied = apply_swap_fee(apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?, fusion_pool.fee_rate, false)?;

            collateral = increase_amount - borrow_with_fees_applied;
            collateral = ceil(collateral as f64 * position_to_borrowed_token_price) as u64;

            // Decrease+Increase swap A->B
            let amount_in = position_amount + apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
            if amount_in > 0 {
                let swap = swap_quote_by_input_token(amount_in, position_token == TOKEN_A, 0, fusion_pool, tick_arrays, None, None)?;
                next_sqrt_price = swap.next_sqrt_price;
                increase_swap_output_amount = swap.token_est_out.saturating_sub(decrease_amount_out);
            }

            // B
            estimated_amount = increase_swap_output_amount + collateral;
        }

        collateral = reverse_apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;

        let new_price = sqrt_price_to_price(next_sqrt_price.into(), 1, 1);
        price_impact = (new_price / price - 1.0).abs();

        increase_min_swap_output_amount = try_get_min_amount_with_slippage_tolerance(increase_swap_output_amount, slippage_tolerance_bps)?;
    }

    let protocol_fee =
        calculate_tuna_protocol_fee(collateral_token, borrowed_token, collateral, borrow, protocol_fee_rate_on_collateral, protocol_fee_rate);

    Ok(DecreaseSpotPositionQuoteResult {
        decrease_percent,
        collateral_token,
        position_token: new_position_token,
        collateral,
        borrow,
        decrease_acceptable_swap_amount,
        increase_min_swap_output_amount,
        estimated_amount,
        protocol_fee_a: protocol_fee.a,
        protocol_fee_b: protocol_fee.b,
        price_impact,
        jupiter_swap_ix,
    })
}

/// Spot position decrease quote
///
/// # Parameters
/// - `decrease_amount`: Position total decrease size in the collateral_token.
/// - `collateral_token`: Collateral token.
/// - `leverage`: Leverage (1.0 or higher).
/// - `reduce_only`: Only allow reducing the existing position.
/// - `slippage_tolerance_bps`: An optional slippage tolerance in basis points. Defaults to the global slippage tolerance if not provided.
/// - `position_token`: Token of the existing position.
/// - `position_amount`: Existing position amount in the position_token.
/// - `position_debt`: Existing position debt in the token opposite to the position_token.
/// - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `fusion_pool`: Fusion pool.
/// - `tick_arrays`: Optional five tick arrays around the current pool price. If not provided, the quote will be calculated using the Jupiter Aggregator.
///
/// # Returns
/// - `DecreaseSpotPositionQuoteResult`: quote result
#[cfg(feature = "wasm")]
#[wasm_bindgen(js_name = "getDecreaseSpotPositionQuote", skip_jsdoc)]
pub async fn wasm_get_decrease_spot_position_quote(
    decrease_amount: u64,
    collateral_token: u8,
    leverage: f64,
    reduce_only: bool,
    slippage_tolerance_bps: Option<u16>,
    position_token: u8,
    position_amount: u64,
    position_debt: u64,
    protocol_fee_rate: u16,
    protocol_fee_rate_on_collateral: u16,
    mint_a: Pubkey,
    mint_b: Pubkey,
    fusion_pool: FusionPoolFacade,
    tick_arrays: Option<TickArrays>,
) -> Result<JsValue, JsValue> {
    let result = get_decrease_spot_position_quote(
        decrease_amount,
        collateral_token,
        leverage,
        reduce_only,
        slippage_tolerance_bps,
        position_token,
        position_amount,
        position_debt,
        protocol_fee_rate,
        protocol_fee_rate_on_collateral,
        mint_a,
        mint_b,
        fusion_pool,
        tick_arrays,
    )
    .await
    .map_err(|e| JsValue::from_str(e))?;

    let serializer = Serializer::new().serialize_maps_as_objects(true);
    let js_value = result.serialize(&serializer).unwrap();

    Ok(js_value)
}

/// Returns the liquidation price
///
/// # Parameters
/// - `position_token`: Token of the position
/// - `amount`: Position total size (decimal)
/// - `debt`: Position total debt (decimal)
/// - `liquidation_threshold`: Liquidation threshold of the market (decimal)
///
/// # Returns
/// - `f64`: Decimal liquidation price
#[cfg_attr(feature = "wasm", wasm_expose)]
pub fn get_liquidation_price(position_token: u8, amount: f64, debt: f64, liquidation_threshold: f64) -> Result<f64, CoreError> {
    if debt < 0.0 || amount < 0.0 {
        return Err(INVALID_ARGUMENTS);
    }

    if liquidation_threshold <= 0.0 || liquidation_threshold >= 1.0 {
        return Err(INVALID_ARGUMENTS);
    }

    if debt == 0.0 || amount == 0.0 {
        return Ok(0.0);
    }

    if position_token == TOKEN_A {
        Ok(debt / (amount * liquidation_threshold))
    } else {
        Ok((amount * liquidation_threshold) / debt)
    }
}

/// Calculates the maximum tradable amount in the collateral token.
///
/// # Parameters
/// - `collateral_token`: Collateral token.
/// - `available_balance`: Available wallet balance in the collateral_token.
/// - `leverage`: Leverage (1.0 or higher).
/// - `new_position_token`: Token of the new position.
/// - `position_token`: Token of the existing position. Should be set to new_position_token if position_amount is zero.
/// - `position_amount`: Existing position amount in the position_token.
/// - `position_debt`: Existing position debt in the token opposite to the position_token.
/// - `reduce_only`: Only allow reducing the existing position.///
/// - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
/// - `fusion_pool`: Fusion pool.
/// - `tick_arrays`: Five tick arrays around the current pool price.
///
/// # Returns
/// - `u64`: the maximum tradable amount
#[cfg_attr(feature = "wasm", wasm_expose)]
pub fn get_tradable_amount(
    collateral_token: u8,
    available_balance: u64,
    leverage: f64,
    new_position_token: u8,
    reduce_only: bool,
    position_token: u8,
    position_amount: u64,
    position_debt: u64,
    protocol_fee_rate: u16,
    protocol_fee_rate_on_collateral: u16,
    fusion_pool: FusionPoolFacade,
    tick_arrays: Option<TickArrays>,
) -> Result<u64, CoreError> {
    if collateral_token > TOKEN_B || position_token > TOKEN_B {
        return Err(INVALID_ARGUMENTS.into());
    }

    if leverage < 1.0 {
        return Err(INVALID_ARGUMENTS.into());
    }

    if position_amount == 0 && new_position_token != position_token {
        return Err(INVALID_ARGUMENTS.into());
    }

    let tick_arrays = tick_arrays.ok_or(INVALID_ARGUMENTS)?;

    // T = C⋅Fc⋅Fs + B⋅Fb⋅Fs, where: Fc/Fb/Fs - collateral/borrow/swap fee multiplier
    // B = T⋅(L - 1) / L
    // => T = C⋅Fc⋅Fs / (1 - Fb⋅Fs⋅(L - 1) / L)
    let add_leverage = |collateral: u64| -> Result<u64, CoreError> {
        let mut collateral = apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;
        if collateral_token != new_position_token {
            collateral = apply_swap_fee(collateral, fusion_pool.fee_rate, false)?;
        }

        let fee_multiplier = (1.0 - protocol_fee_rate as f64 / HUNDRED_PERCENT as f64) * (1.0 - fusion_pool.fee_rate as f64 / 1_000_000.0);
        let total = (collateral as f64 / (1.0 - (fee_multiplier * (leverage - 1.0)) / leverage)) as u64;
        Ok(total)
    };

    let available_to_trade = if new_position_token == position_token {
        add_leverage(available_balance)?
    } else {
        let price = sqrt_price_to_price(fusion_pool.sqrt_price.into(), 1, 1);
        let position_to_opposite_token_price = if position_token == TOKEN_A { price } else { 1.0 / price };

        if reduce_only {
            if collateral_token == position_token {
                position_amount
            } else {
                round(position_amount as f64 * position_to_opposite_token_price) as u64
            }
        } else {
            let position_amount_in_collateral_token = if collateral_token == position_token {
                position_amount
            } else {
                round(position_amount as f64 * position_to_opposite_token_price) as u64
            };

            let position_collateral = if collateral_token == position_token {
                let swap_in = if position_debt > 0 {
                    swap_quote_by_output_token(position_debt, position_token == TOKEN_B, 0, fusion_pool, tick_arrays, None, None)?.token_est_in
                } else {
                    0
                };
                position_amount - swap_in
            } else {
                if position_amount > 0 {
                    let swap_quote = swap_quote_by_input_token(position_amount, position_token == TOKEN_A, 0, fusion_pool, tick_arrays, None, None)?;
                    swap_quote.token_est_out - position_debt
                } else {
                    0
                }
            };

            // Add the refunded collateral to the available balance
            position_amount_in_collateral_token + add_leverage(available_balance + position_collateral)?
        }
    };

    Ok(available_to_trade)
}

pub fn apply_tuna_protocol_fee(amount: u64, protocol_fee_rate: u16, round_up: bool) -> Result<u64, CoreError> {
    try_mul_div(amount, HUNDRED_PERCENT as u128 - protocol_fee_rate as u128, HUNDRED_PERCENT as u128, round_up)
}

pub fn reverse_apply_tuna_protocol_fee(amount: u64, protocol_fee_rate: u16, round_up: bool) -> Result<u64, CoreError> {
    try_mul_div(amount, HUNDRED_PERCENT as u128, HUNDRED_PERCENT as u128 - protocol_fee_rate as u128, round_up)
}

pub fn apply_swap_fee(amount: u64, fee_rate: u16, round_up: bool) -> Result<u64, CoreError> {
    try_mul_div(amount, 1_000_000 - fee_rate as u128, 1_000_000, round_up)
}

pub fn reverse_apply_swap_fee(amount: u64, fee_rate: u16, round_up: bool) -> Result<u64, CoreError> {
    try_mul_div(amount, 1_000_000, 1_000_000 - fee_rate as u128, round_up)
}

#[cfg_attr(feature = "wasm", wasm_expose)]
pub fn calculate_tuna_protocol_fee(
    collateral_token: u8,
    borrowed_token: u8,
    collateral: u64,
    borrow: u64,
    protocol_fee_rate_on_collateral: u16,
    protocol_fee_rate: u16,
) -> TokenPair {
    let collateral_a = if collateral_token == TOKEN_A { collateral } else { 0 };
    let collateral_b = if collateral_token == TOKEN_B { collateral } else { 0 };
    let borrow_a = if borrowed_token == TOKEN_A { borrow } else { 0 };
    let borrow_b = if borrowed_token == TOKEN_B { borrow } else { 0 };

    let protocol_fee_a = ((collateral_a as u128 * protocol_fee_rate_on_collateral as u128 + borrow_a as u128 * protocol_fee_rate as u128)
        / HUNDRED_PERCENT as u128) as u64;
    let protocol_fee_b = ((collateral_b as u128 * protocol_fee_rate_on_collateral as u128 + borrow_b as u128 * protocol_fee_rate as u128)
        / HUNDRED_PERCENT as u128) as u64;

    TokenPair {
        a: protocol_fee_a,
        b: protocol_fee_b,
    }
}

struct JupiterSwapResult {
    pub instruction: SwapInstruction,
    pub out_amount: u64,
    pub other_amount_threshold: u64,
    pub price_impact_pct: f64,
}

async fn jupiter_swap_quote(input_mint: Pubkey, output_mint: Pubkey, amount: u64, slippage_bps: Option<u64>) -> Result<JupiterSwapResult, CoreError> {
    let quote_config = QuoteConfig {
        slippage_bps,
        swap_mode: Some(SwapMode::ExactIn),
        dexes: None,
        exclude_dexes: None,
        only_direct_routes: false,
        as_legacy_transaction: None,
        platform_fee_bps: None,
        max_accounts: None,
    };

    let quote = jup_ag::quote(input_mint, output_mint, amount, quote_config)
        .await
        .map_err(|_| JUPITER_QUOTE_REQUEST_ERROR)?;

    #[allow(deprecated)]
    let swap_request = SwapRequest {
        user_public_key: Default::default(),
        wrap_and_unwrap_sol: None,
        use_shared_accounts: Some(true),
        fee_account: None,
        compute_unit_price_micro_lamports: None,
        prioritization_fee_lamports: PrioritizationFeeLamports::Auto,
        as_legacy_transaction: None,
        use_token_ledger: None,
        destination_token_account: None,
        quote_response: quote.clone(),
    };

    let swap_response = jup_ag::swap_instructions(swap_request)
        .await
        .map_err(|_| JUPITER_SWAP_INSTRUCTIONS_REQUEST_ERROR)?;

    Ok(JupiterSwapResult {
        instruction: SwapInstruction {
            data: swap_response.swap_instruction.data,
            accounts: swap_response.swap_instruction.accounts,
            address_lookup_table_addresses: swap_response.address_lookup_table_addresses,
        },
        out_amount: quote.out_amount,
        other_amount_threshold: quote.other_amount_threshold,
        price_impact_pct: quote.price_impact_pct,
    })
}

#[cfg(all(test, not(feature = "wasm")))]
mod tests {
    use super::*;
    use crate::assert_approx_eq;
    use fusionamm_core::{
        get_tick_array_start_tick_index, price_to_sqrt_price, sqrt_price_to_tick_index, TickArrayFacade, TickFacade, TICK_ARRAY_SIZE,
    };
    use solana_pubkey::pubkey;

    const NATIVE_MINT: Pubkey = pubkey!("So11111111111111111111111111111111111111112");
    const TUNA_MINT: Pubkey = pubkey!("TUNAfXDZEdQizTMTh3uEvNvYqJmqFHZbEJt8joP4cyx");

    fn test_fusion_pool(sqrt_price: u128) -> FusionPoolFacade {
        let tick_current_index = sqrt_price_to_tick_index(sqrt_price);
        FusionPoolFacade {
            tick_current_index,
            fee_rate: 3000,
            liquidity: 10000000000000,
            sqrt_price,
            tick_spacing: 2,
            ..FusionPoolFacade::default()
        }
    }

    fn test_tick(liquidity_net: i128) -> TickFacade {
        TickFacade {
            initialized: true,
            liquidity_net,
            ..TickFacade::default()
        }
    }

    fn test_tick_array(start_tick_index: i32) -> TickArrayFacade {
        TickArrayFacade {
            start_tick_index,
            ticks: [test_tick(0); TICK_ARRAY_SIZE],
        }
    }

    fn test_tick_arrays(fusion_pool: FusionPoolFacade) -> TickArrays {
        let tick_spacing = fusion_pool.tick_spacing;
        let tick_current_index = sqrt_price_to_tick_index(fusion_pool.sqrt_price);
        let tick_array_start_index = get_tick_array_start_tick_index(tick_current_index, tick_spacing);

        [
            test_tick_array(tick_array_start_index),
            test_tick_array(tick_array_start_index + TICK_ARRAY_SIZE as i32 * tick_spacing as i32),
            test_tick_array(tick_array_start_index + TICK_ARRAY_SIZE as i32 * tick_spacing as i32 * 2),
            test_tick_array(tick_array_start_index - TICK_ARRAY_SIZE as i32 * tick_spacing as i32),
            test_tick_array(tick_array_start_index - TICK_ARRAY_SIZE as i32 * tick_spacing as i32 * 2),
        ]
        .into()
    }

    #[test]
    fn test_get_liquidation_price() {
        assert_eq!(get_liquidation_price(TOKEN_A, 5.0, 0.0, 0.85), Ok(0.0));
        assert_eq!(get_liquidation_price(TOKEN_A, 0.0, 5.0, 0.85), Ok(0.0));
        assert_eq!(get_liquidation_price(TOKEN_A, 5.0, 800.0, 0.85), Ok(188.23529411764707));
        assert_eq!(get_liquidation_price(TOKEN_B, 1000.0, 4.0, 0.85), Ok(212.5));
    }

    #[tokio::test]
    async fn increase_long_position_providing_token_a() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_increase_spot_position_quote(
            5_000_000_000,
            TOKEN_A,
            TOKEN_A,
            5.0,
            Some(0),
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.collateral, 1057165829);
        assert_eq!(quote.borrow, 800000000);
        assert_eq!(quote.min_swap_output_amount, 3_947_423_011);
        assert_eq!(quote.estimated_amount, 4_999_303_011);
        assert_eq!(quote.protocol_fee_a, 5285829);
        assert_eq!(quote.protocol_fee_b, 8000000);
        assert_eq!(quote.price_impact, 0.00035316176257027543);
        assert_approx_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 * 1000.0) / 200.0), 5.0, 0.1);
    }

    #[tokio::test]
    async fn increase_long_position_providing_token_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_increase_spot_position_quote(
            5000_000_000,
            TOKEN_B,
            TOKEN_A,
            5.0,
            Some(0),
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.collateral, 1060346869);
        assert_eq!(quote.borrow, 4000000000);
        assert_eq!(quote.estimated_amount, 24_972_080_293);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 45301734);
        assert_eq!(quote.price_impact, 0.0022373179716579372);
        assert_approx_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 * 1000.0) / 200.0), 5.0, 0.1);
    }

    #[tokio::test]
    async fn increase_short_position_providing_a() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_increase_spot_position_quote(
            5_000_000_000,
            TOKEN_A,
            TOKEN_B,
            5.0,
            Some(0),
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.collateral, 1060346869);
        assert_eq!(quote.borrow, 4000000000);
        assert_eq!(quote.estimated_amount, 999_776_441);
        assert_eq!(quote.protocol_fee_a, 45301734);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.0004470636400017991);
        assert_approx_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 / 1000.0) * 200.0), 5.0, 0.1);
    }

    #[tokio::test]
    async fn increase_short_position_providing_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_increase_spot_position_quote(
            5000_000_000,
            TOKEN_B,
            TOKEN_B,
            5.0,
            Some(0),
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.collateral, 1057165829);
        assert_eq!(quote.borrow, 20000000000);
        assert_eq!(quote.estimated_amount, 4996_517_564);
        assert_eq!(quote.protocol_fee_a, 200000000);
        assert_eq!(quote.protocol_fee_b, 5285829);
        assert_eq!(quote.price_impact, 0.0017633175413067637);
        assert_approx_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 / 1000.0) * 200.0), 5.0, 0.1);
    }

    #[tokio::test]
    async fn increase_quote_with_slippage() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        // with slippage 10%
        let quote = get_increase_spot_position_quote(
            200_000,
            TOKEN_B,
            TOKEN_A,
            5.0,
            Some(1000),
            0,
            0,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();
        assert_eq!(quote.min_swap_output_amount, 899_994);

        // without slippage
        let quote = get_increase_spot_position_quote(
            200_000,
            TOKEN_B,
            TOKEN_A,
            5.0,
            Some(0),
            0,
            0,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();
        assert_eq!(quote.min_swap_output_amount, 999_994);
    }

    #[tokio::test]
    async fn decrease_non_leveraged_long_position_providing_a_reduce_only() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            1_000_000_000,
            TOKEN_A,
            1.0,
            true,
            Some(0),
            TOKEN_A,
            5_000_000_000, // A
            0,             // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, TOKEN_A);
        assert_eq!(quote.position_token, TOKEN_A);
        assert_eq!(quote.estimated_amount, 4_000_000_000);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.0);
        assert_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 / 1000.0) * 200.0), 1.0);
    }

    #[tokio::test]
    async fn decrease_non_leveraged_long_position_providing_b_reduce_only() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            200_000_000,
            TOKEN_B,
            1.0,
            true,
            Some(0),
            TOKEN_A,
            5_000_000_000, // A
            0,             // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, TOKEN_B);
        assert_eq!(quote.position_token, TOKEN_A);
        assert_eq!(quote.estimated_amount, 4_000_000_000);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.00008916842709072448);
        assert_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 / 1000.0) * 200.0), 1.0);
    }

    #[tokio::test]
    async fn decrease_long_position_providing_a_reduce_only() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            1_000_000_000,
            TOKEN_A,
            5.0,
            true,
            Some(0),
            TOKEN_A,
            5_000_000_000, // A
            800_000_000,   // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, TOKEN_A);
        assert_eq!(quote.position_token, TOKEN_A);
        assert_eq!(quote.collateral, 0);
        assert_eq!(quote.borrow, 0);
        assert_eq!(quote.estimated_amount, 4_000_000_000);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.00007155289528004705);

        let quote = get_decrease_spot_position_quote(
            6_000_000_000,
            TOKEN_A,
            5.0,
            true,
            Some(0),
            TOKEN_A,
            5_000_000_000, // A
            800_000_000,   // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral, 0);
        assert_eq!(quote.borrow, 0);
        assert_eq!(quote.estimated_amount, 0);
    }

    #[tokio::test]
    async fn decrease_long_position_providing_b_reduce_only() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            200_000_000,
            TOKEN_B,
            5.0,
            true,
            Some(0),
            TOKEN_A,
            5_000_000_000, // A
            800_000_000,   // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, TOKEN_B);
        assert_eq!(quote.position_token, TOKEN_A);
        assert_eq!(quote.collateral, 0);
        assert_eq!(quote.borrow, 0);
        assert_eq!(quote.estimated_amount, 4000000000);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.00008916842709072448);

        let quote = get_decrease_spot_position_quote(
            1200_000_000,
            TOKEN_B,
            5.0,
            true,
            Some(0),
            TOKEN_A,
            5_000_000_000, // A
            800_000_000,   // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral, 0);
        assert_eq!(quote.borrow, 0);
        assert_eq!(quote.estimated_amount, 0);
    }

    #[tokio::test]
    async fn decrease_long_position_providing_a_without_leverage() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            6_000_000_000,
            TOKEN_A,
            1.0,
            false,
            Some(100),
            TOKEN_A,
            5_000_000_000, // A
            800_000_000,   // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, TOKEN_A);
        assert_eq!(quote.position_token, TOKEN_B);
        assert_eq!(quote.collateral, 1005025125);
        assert_eq!(quote.borrow, 0);
        assert_eq!(quote.estimated_amount, 199_319_781);
        assert_eq!(quote.decrease_acceptable_swap_amount, 4_052_881_482);
        assert_eq!(quote.increase_min_swap_output_amount, 197_326_583);
        assert_eq!(quote.protocol_fee_a, 5025125);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.00044685946117650754);
    }

    #[tokio::test]
    async fn decrease_long_position_providing_a() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            6_000_000_000,
            TOKEN_A,
            5.0,
            false,
            Some(100),
            TOKEN_A,
            5_000_000_000, // A
            800_000_000,   // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, TOKEN_A);
        assert_eq!(quote.position_token, TOKEN_B);
        assert_eq!(quote.collateral, 211433165);
        assert_eq!(quote.borrow, 800000000);
        assert_eq!(quote.estimated_amount, 199_793_344);
        assert_eq!(quote.decrease_acceptable_swap_amount, 4_052_881_482);
        assert_eq!(quote.increase_min_swap_output_amount, 197_795_410);
        assert_eq!(quote.protocol_fee_a, 1057165);
        assert_eq!(quote.protocol_fee_b, 8000000);
        assert_eq!(quote.price_impact, 0.0004470711974918773);
    }

    #[tokio::test]
    async fn decrease_long_position_providing_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            1200_000_000,
            TOKEN_B,
            5.0,
            false,
            Some(0),
            TOKEN_A,
            5_000_000_000, // A
            800_000_000,   // B
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, TOKEN_B);
        assert_eq!(quote.position_token, TOKEN_B);
        assert_eq!(quote.collateral, 42286633);
        assert_eq!(quote.borrow, 800_000_000);
        assert_eq!(quote.estimated_amount, 199_924_036);
        assert_eq!(quote.decrease_acceptable_swap_amount, 996_777_780);
        assert_eq!(quote.increase_min_swap_output_amount, 157_848_836);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 8211433);
        assert_eq!(quote.price_impact, 0.0005162980632488212);
    }

    #[tokio::test]
    async fn decrease_non_leveraged_short_position_providing_a() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            6_000_000_000,
            TOKEN_A,
            1.0,
            false,
            Some(0),
            TOKEN_B,
            1000_000_000, // B
            0,            // A
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, TOKEN_A);
        assert_eq!(quote.position_token, TOKEN_A);
        assert_eq!(quote.collateral, 1005025125);
        assert_eq!(quote.borrow, 0);
        assert_eq!(quote.estimated_amount, 1_000_000_000);
        assert_eq!(quote.protocol_fee_a, 5025125);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.00044592165429757635);
    }

    #[tokio::test]
    async fn decrease_short_position_providing_a() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            6_000_000_000,
            TOKEN_A,
            5.0,
            false,
            Some(0),
            TOKEN_B,
            1000_000_000,  // B
            4_000_000_000, // A
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, TOKEN_A);
        assert_eq!(quote.position_token, TOKEN_A);
        assert_eq!(quote.collateral, 211433165);
        assert_eq!(quote.borrow, 160000000);
        assert_eq!(quote.estimated_amount, 999_620_182);
        assert_eq!(quote.decrease_acceptable_swap_amount, 4_983_888_901);
        assert_eq!(quote.increase_min_swap_output_amount, 789_244_182);
        assert_eq!(quote.protocol_fee_a, 2657165);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.00051656476403882934);
    }

    #[tokio::test]
    async fn decrease_short_position_providing_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);

        let quote = get_decrease_spot_position_quote(
            1_200_000_000,
            TOKEN_B,
            5.0,
            false,
            Some(0),
            TOKEN_B,
            1000_000_000,  // B
            4_000_000_000, // A
            (HUNDRED_PERCENT / 100) as u16,
            (HUNDRED_PERCENT / 200) as u16,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            Some(test_tick_arrays(fusion_pool)),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, TOKEN_B);
        assert_eq!(quote.position_token, TOKEN_A);
        assert_eq!(quote.collateral, 42_286_633);
        assert_eq!(quote.borrow, 160000000);
        assert_eq!(quote.estimated_amount, 998_966_727);
        assert_eq!(quote.protocol_fee_a, 1600000);
        assert_eq!(quote.protocol_fee_b, 211433);
        assert_eq!(quote.price_impact, 0.00044727115960174757);
    }

    #[tokio::test]
    async fn tradable_amount_for_1x_long_position_providing_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);
        let tick_arrays = Some(test_tick_arrays(fusion_pool));

        let collateral_token = TOKEN_B;
        let position_token = TOKEN_A;
        let leverage = 1.0;
        let protocol_fee_rate = (HUNDRED_PERCENT / 100) as u16;
        let protocol_fee_rate_on_collateral = (HUNDRED_PERCENT / 200) as u16;
        let available_balance = 200_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            position_token,
            false,
            position_token,
            0,
            0,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();
        assert_eq!(tradable_amount, 198403000);

        let quote = get_increase_spot_position_quote(
            tradable_amount,
            collateral_token,
            position_token,
            leverage,
            Some(0),
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            tick_arrays,
        )
        .await
        .unwrap();
        assert_eq!(quote.collateral, available_balance);
    }

    #[tokio::test]
    async fn tradable_amount_for_5x_long_position_providing_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);
        let tick_arrays = Some(test_tick_arrays(fusion_pool));

        let collateral_token = TOKEN_B;
        let position_token = TOKEN_A;
        let leverage = 5.0;
        let protocol_fee_rate = (HUNDRED_PERCENT / 100) as u16;
        let protocol_fee_rate_on_collateral = (HUNDRED_PERCENT / 200) as u16;
        let available_balance = 10_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            position_token,
            false,
            position_token,
            0,
            0,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();
        assert_eq!(tradable_amount, 47154380);

        let quote = get_increase_spot_position_quote(
            tradable_amount,
            collateral_token,
            position_token,
            leverage,
            Some(0),
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            tick_arrays,
        )
        .await
        .unwrap();
        // TODO: fix precision error
        assert_eq!(quote.collateral, available_balance + 1);
    }

    #[tokio::test]
    async fn tradable_amount_for_5x_long_position_providing_a() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);
        let tick_arrays = Some(test_tick_arrays(fusion_pool));

        let collateral_token = TOKEN_A;
        let position_token = TOKEN_A;
        let leverage = 5.0;
        let protocol_fee_rate = (HUNDRED_PERCENT / 100) as u16;
        let protocol_fee_rate_on_collateral = (HUNDRED_PERCENT / 200) as u16;
        let available_balance = 1_000_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            position_token,
            false,
            position_token,
            0,
            0,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();
        assert_eq!(tradable_amount, 4729626953);

        let quote = get_increase_spot_position_quote(
            tradable_amount,
            collateral_token,
            position_token,
            leverage,
            Some(0),
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            tick_arrays,
        )
        .await
        .unwrap();
        assert_eq!(quote.collateral, available_balance);
        //assert_eq!(quote.estimated_amount, tradable_amount);
    }

    #[tokio::test]
    async fn tradable_amount_for_5x_short_position_providing_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);
        let tick_arrays = Some(test_tick_arrays(fusion_pool));

        let collateral_token = TOKEN_B;
        let position_token = TOKEN_B;
        let leverage = 5.0;
        let protocol_fee_rate = (HUNDRED_PERCENT / 100) as u16;
        let protocol_fee_rate_on_collateral = (HUNDRED_PERCENT / 200) as u16;
        let available_balance = 200_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            position_token,
            false,
            position_token,
            0,
            0,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();
        assert_eq!(tradable_amount, 945925390);

        let quote = get_increase_spot_position_quote(
            tradable_amount,
            collateral_token,
            position_token,
            leverage,
            Some(0),
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            tick_arrays,
        )
        .await
        .unwrap();
        // TODO: fix precision error
        assert_eq!(quote.collateral, available_balance + 1);
        //assert_eq!(quote.estimated_amount, tradable_amount);
    }

    #[tokio::test]
    async fn tradable_amount_for_reducing_existing_long_position() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);
        let tick_arrays = Some(test_tick_arrays(fusion_pool));

        for i in 0..2 {
            let collateral_token = if i == 0 { TOKEN_A } else { TOKEN_B };
            let position_token = if i == 0 { TOKEN_A } else { TOKEN_B };
            let leverage = 5.0;
            let reduce_only = true;
            let position_amount = 5_000_000_000;
            let position_debt = 800_000_000;
            let protocol_fee_rate = (HUNDRED_PERCENT / 100) as u16;
            let protocol_fee_rate_on_collateral = (HUNDRED_PERCENT / 200) as u16;
            let available_balance = 50_000_000_000;

            let tradable_amount = get_tradable_amount(
                collateral_token,
                available_balance,
                leverage,
                if position_token == TOKEN_A { TOKEN_B } else { TOKEN_A },
                reduce_only,
                position_token,
                position_amount,
                position_debt,
                protocol_fee_rate,
                protocol_fee_rate_on_collateral,
                fusion_pool,
                tick_arrays.clone(),
            )
            .unwrap();
            assert_eq!(tradable_amount, 5_000_000_000);

            let quote = get_decrease_spot_position_quote(
                tradable_amount,
                collateral_token,
                5.0,
                reduce_only,
                Some(0),
                position_token,
                position_amount,
                position_debt,
                protocol_fee_rate,
                protocol_fee_rate_on_collateral,
                NATIVE_MINT,
                TUNA_MINT,
                fusion_pool,
                tick_arrays.clone(),
            )
            .await
            .unwrap();

            assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        }
    }

    #[tokio::test]
    async fn tradable_amount_when_inverting_long_position_providing_a() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);
        let tick_arrays = Some(test_tick_arrays(fusion_pool));

        let collateral_token = TOKEN_A;
        let position_token = TOKEN_A;
        let leverage = 5.0;
        let reduce_only = false;
        let position_amount = 5_000_000_000;
        let position_debt = 800_000_000;
        let protocol_fee_rate = (HUNDRED_PERCENT / 100) as u16;
        let protocol_fee_rate_on_collateral = (HUNDRED_PERCENT / 200) as u16;
        let available_balance = 2_000_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            if position_token == TOKEN_A { TOKEN_B } else { TOKEN_A },
            reduce_only,
            position_token,
            position_amount,
            position_debt,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();
        assert_eq!(tradable_amount, 19_086_173_788);

        let quote = get_decrease_spot_position_quote(
            tradable_amount,
            collateral_token,
            5.0,
            reduce_only,
            Some(0),
            position_token,
            position_amount,
            position_debt,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            tick_arrays.clone(),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral, 2_978_284_319);
    }

    #[tokio::test]
    async fn tradable_amount_when_inverting_long_position_providing_b() {
        let sqrt_price = price_to_sqrt_price(200.0, 9, 6);
        let fusion_pool = test_fusion_pool(sqrt_price);
        let tick_arrays = Some(test_tick_arrays(fusion_pool));

        let collateral_token = TOKEN_B;
        let position_token = TOKEN_A;
        let leverage = 5.0;
        let reduce_only = false;
        let position_amount = 5_000_000_000;
        let position_debt = 800_000_000;
        let protocol_fee_rate = (HUNDRED_PERCENT / 100) as u16;
        let protocol_fee_rate_on_collateral = (HUNDRED_PERCENT / 200) as u16;
        let available_balance = 500_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            if position_token == TOKEN_A { TOKEN_B } else { TOKEN_A },
            reduce_only,
            position_token,
            position_amount,
            position_debt,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();
        assert_eq!(tradable_amount, 4_295_498_968);

        let quote = get_decrease_spot_position_quote(
            tradable_amount,
            collateral_token,
            5.0,
            reduce_only,
            Some(0),
            position_token,
            position_amount,
            position_debt,
            protocol_fee_rate,
            protocol_fee_rate_on_collateral,
            NATIVE_MINT,
            TUNA_MINT,
            fusion_pool,
            tick_arrays.clone(),
        )
        .await
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral, 696_777_779);
    }
}