defituna_core/quote/

tuna_spot_position.rs

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

use crate::{CoreError, HUNDRED_PERCENT, INVALID_ARGUMENTS, 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,
};
use libm::{ceil, round};

pub const DEFAULT_SLIPPAGE_TOLERANCE_BPS: u16 = 100;

#[cfg(feature = "wasm")]
use fusionamm_macros::wasm_expose;

#[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 */
    pub price_impact: f64,
}

/// 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).
/// - `fusion_pool`: Fusion pool.
/// - `tick_arrays`: Five tick arrays around the current pool price.
///
/// # Returns
/// - `IncreaseSpotPositionQuoteResult`: quote result
#[cfg_attr(feature = "wasm", wasm_expose)]
pub 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,
    fusion_pool: FusionPoolFacade,
    tick_arrays: 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 next_sqrt_price = fusion_pool.sqrt_price;
    let mut min_swap_output_amount: u64 = 0;

    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_a, protocol_fee_b) =
        compute_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 {
        let swap = swap_quote_by_input_token(swap_input_amount, swap_input_token_is_a, 0, fusion_pool, tick_arrays, None, None)?;
        estimated_amount += swap.token_est_out;
        next_sqrt_price = swap.next_sqrt_price;
        min_swap_output_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);
    let price_impact = (new_price / price - 1.0).abs() * 100.0;

    Ok(IncreaseSpotPositionQuoteResult {
        collateral,
        borrow,
        estimated_amount,
        swap_input_amount,
        min_swap_output_amount,
        protocol_fee_a,
        protocol_fee_b,
        price_impact,
    })
}

#[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 */
    pub price_impact: f64,
}

/// 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`: Five tick arrays around the current pool price.
///
/// # Returns
/// - `DecreaseSpotPositionQuoteResult`: quote result
#[cfg_attr(feature = "wasm", wasm_expose)]
pub 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,
    fusion_pool: FusionPoolFacade,
    tick_arrays: 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 next_sqrt_price = fusion_pool.sqrt_price;
    let mut new_position_token = position_token;
    let decrease_percent: u32;
    let mut increase_swap_output_amount: u64 = 0;
    let mut decrease_acceptable_swap_amount: u64 = 0;

    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;
    }

    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 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)?;
        }
    } else {
        new_position_token = if position_token == TOKEN_A { TOKEN_B } else { TOKEN_A };
        let increase_amount = decrease_amount_in_position_token - position_amount;

        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 (protocol_fee_a, protocol_fee_b) =
        compute_tuna_protocol_fee(collateral_token, borrowed_token, collateral, borrow, protocol_fee_rate_on_collateral, protocol_fee_rate);

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

    let increase_min_swap_output_amount = try_get_min_amount_with_slippage_tolerance(increase_swap_output_amount, slippage_tolerance_bps)?;

    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_b,
        price_impact,
    })
}

/// 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: 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());
    }

    // 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)
}

pub fn compute_tuna_protocol_fee(
    collateral_token: u8,
    borrowed_token: u8,
    collateral: u64,
    borrow: u64,
    protocol_fee_rate_on_collateral: u16,
    protocol_fee_rate: u16,
) -> (u64, u64) {
    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;

    (protocol_fee_a, protocol_fee_b)
}

#[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,
    };

    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));
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.03531617625702754);
        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);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.22373179716579372);
        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);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.04470636400017991);
        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);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.17633175413067637);
        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);
    }

    #[test]
    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, fusion_pool, test_tick_arrays(fusion_pool)).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, fusion_pool, test_tick_arrays(fusion_pool)).unwrap();
        assert_eq!(quote.min_swap_output_amount, 999_994);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.008916842709072448);
        assert_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 / 1000.0) * 200.0), 1.0);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.007155289528004705);

        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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

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

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.008916842709072448);

        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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

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

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.044685946117650754);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.04470711974918773);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.05162980632488212);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.044592165429757635);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.051656476403882934);
    }

    #[test]
    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,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .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.04472711596017476);
    }

    #[test]
    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 = 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,
            fusion_pool,
            tick_arrays,
        )
        .unwrap();
        assert_eq!(quote.collateral, available_balance);
    }

    #[test]
    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 = 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,
            fusion_pool,
            tick_arrays,
        )
        .unwrap();
        // TODO: fix precision error
        assert_eq!(quote.collateral, available_balance + 1);
    }

    #[test]
    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 = 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,
            fusion_pool,
            tick_arrays,
        )
        .unwrap();
        assert_eq!(quote.collateral, available_balance);
        //assert_eq!(quote.estimated_amount, tradable_amount);
    }

    #[test]
    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 = 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,
            fusion_pool,
            tick_arrays,
        )
        .unwrap();
        // TODO: fix precision error
        assert_eq!(quote.collateral, available_balance + 1);
        //assert_eq!(quote.estimated_amount, tradable_amount);
    }

    #[test]
    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 = 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,
                fusion_pool,
                tick_arrays.clone(),
            )
            .unwrap();

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

    #[test]
    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 = 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,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();

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

    #[test]
    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 = 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,
            fusion_pool,
            tick_arrays.clone(),
        )
        .unwrap();

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