defituna_core/quote/

tuna_spot_position.rs

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

use crate::{CoreError, PoolTokenFacade, HUNDRED_PERCENT, INVALID_ARGUMENTS};
use fusionamm_core::{sqrt_price_to_price, swap_quote_by_input_token, swap_quote_by_output_token, try_mul_div, FusionPoolFacade, TickArrays};
use libm::{ceil, round};

#[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,
    /** 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).
/// - `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: PoolTokenFacade,
    position_token: PoolTokenFacade,
    leverage: f64,
    protocol_fee_rate: u32,
    protocol_fee_rate_on_collateral: u32,
    fusion_pool: FusionPoolFacade,
    tick_arrays: TickArrays,
) -> Result<IncreaseSpotPositionQuoteResult, CoreError> {
    if leverage < 1.0 {
        return Err(INVALID_ARGUMENTS.into());
    }

    if protocol_fee_rate >= HUNDRED_PERCENT {
        return Err(INVALID_ARGUMENTS.into());
    }

    if protocol_fee_rate_on_collateral >= HUNDRED_PERCENT {
        return Err(INVALID_ARGUMENTS.into());
    }

    let borrow: u64;
    let mut collateral: u64;
    let estimated_amount: u64;
    let swap_input_amount: u64;
    let mut next_sqrt_price = fusion_pool.sqrt_price;

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

    if position_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 = increase_amount;
        estimated_amount = round(if collateral_token == PoolTokenFacade::A {
            increase_amount as f64 * price
        } else {
            increase_amount as f64 / price
        }) as u64;
    } else {
        let position_to_borrowed_token_price = if collateral_token == PoolTokenFacade::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 = apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
        estimated_amount = increase_amount;
    }

    if swap_input_amount > 0 {
        let is_token_a = position_token == PoolTokenFacade::B;
        next_sqrt_price = swap_quote_by_input_token(swap_input_amount, is_token_a, 0, fusion_pool, tick_arrays, None, None)?.next_sqrt_price;
    }

    let mut protocol_fee_a = 0;
    let mut protocol_fee_b = 0;

    if collateral_token == PoolTokenFacade::A {
        protocol_fee_a += collateral - apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;
    } else {
        protocol_fee_b += collateral - apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;
    }

    if position_token == PoolTokenFacade::B {
        protocol_fee_a += borrow - apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
    } else {
        protocol_fee_b += borrow - apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
    }

    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,
        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: PoolTokenFacade,
    /** Token of the new position */
    pub position_token: PoolTokenFacade,
    /** Required additional collateral amount */
    pub collateral: u64,
    /** Required amount to borrow */
    pub borrow: u64,
    /** Swap input amount. */
    pub swap_input_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
/// - `increase_amount`: Position total size in the collateral_token.
/// - `collateral_token`: Collateral token.
/// - `position_token`: Token of the existing position.
/// - `leverage`: Leverage (1.0 or higher).
/// - `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
/// - `DecreaseSpotPositionQuoteResult`: quote result
#[cfg_attr(feature = "wasm", wasm_expose)]
pub fn get_decrease_spot_position_quote(
    decrease_amount: u64,
    collateral_token: PoolTokenFacade,
    leverage: f64,
    reduce_only: bool,
    position_token: PoolTokenFacade,
    position_amount: u64,
    position_debt: u64,
    protocol_fee_rate: u32,
    protocol_fee_rate_on_collateral: u32,
    fusion_pool: FusionPoolFacade,
    tick_arrays: TickArrays,
) -> Result<DecreaseSpotPositionQuoteResult, CoreError> {
    if leverage < 1.0 {
        return Err(INVALID_ARGUMENTS.into());
    }

    if protocol_fee_rate >= HUNDRED_PERCENT {
        return Err(INVALID_ARGUMENTS.into());
    }

    if protocol_fee_rate_on_collateral >= HUNDRED_PERCENT {
        return Err(INVALID_ARGUMENTS.into());
    }

    let mut collateral = 0;
    let mut borrow = 0;
    let mut swap_input_amount = 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;

    // Current pool price
    let price = sqrt_price_to_price(fusion_pool.sqrt_price.into(), 1, 1);
    let position_to_opposite_token_price = if position_token == PoolTokenFacade::A { price } else { 1.0 / price };

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

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

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

        estimated_amount = position_amount - decrease_amount_in_position_token;

        if collateral_token == position_token {
            if position_debt > 0 {
                let swap_out = position_debt * decrease_percent as u64 / HUNDRED_PERCENT as u64;
                let swap_quote = swap_quote_by_output_token(swap_out, position_token == PoolTokenFacade::B, 0, fusion_pool, tick_arrays, None, None)?;
                next_sqrt_price = swap_quote.next_sqrt_price;
                swap_input_amount = swap_quote.token_est_in;
            }
        } else {
            swap_input_amount = position_amount - position_amount * (HUNDRED_PERCENT - decrease_percent) as u64 / HUNDRED_PERCENT as u64;
            let swap_quote =
                swap_quote_by_input_token(swap_input_amount, position_token == PoolTokenFacade::A, 0, fusion_pool, tick_arrays, None, None)?;
            next_sqrt_price = swap_quote.next_sqrt_price;
        }
    } else {
        decrease_percent = HUNDRED_PERCENT;
        new_position_token = if position_token == PoolTokenFacade::A {
            PoolTokenFacade::B
        } else {
            PoolTokenFacade::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

            // B
            estimated_amount = round(increase_amount as f64 * position_to_opposite_token_price) as u64;

            // A
            borrow = round((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;

            // B->A
            if position_debt > 0 {
                let swap_quote = swap_quote_by_output_token(
                    position_debt,
                    position_token != PoolTokenFacade::A,
                    0,
                    fusion_pool,
                    tick_arrays.clone().into(),
                    None,
                    None,
                )?;
                swap_input_amount = swap_quote.token_est_in;
            }

            swap_input_amount += collateral + apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
            let swap_quote =
                swap_quote_by_input_token(swap_input_amount, position_token == PoolTokenFacade::A, 0, fusion_pool, tick_arrays, None, None)?;
            next_sqrt_price = swap_quote.next_sqrt_price;

            collateral = reverse_apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;
        } else {
            // Example:
            // collateral_token: B
            // position_token: A
            // new_position_token: B
            // newBorrowedToken: A

            // B
            estimated_amount = round(increase_amount as f64 * position_to_opposite_token_price) as u64;

            borrow = round((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 = round(collateral as f64 * position_to_opposite_token_price) as u64;
            collateral = reverse_apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;

            // A->B
            swap_input_amount = position_amount + apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
            let swap_quote =
                swap_quote_by_input_token(swap_input_amount, position_token == PoolTokenFacade::A, 0, fusion_pool, tick_arrays, None, None)?;
            next_sqrt_price = swap_quote.next_sqrt_price;
        }
    }

    let mut protocol_fee_a = 0;
    let mut protocol_fee_b = 0;

    if collateral_token == PoolTokenFacade::A {
        protocol_fee_a += collateral - apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;
    } else {
        protocol_fee_b += collateral - apply_tuna_protocol_fee(collateral, protocol_fee_rate_on_collateral, false)?;
    }

    if position_token == PoolTokenFacade::B {
        protocol_fee_a += borrow - apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
    } else {
        protocol_fee_b += borrow - apply_tuna_protocol_fee(borrow, protocol_fee_rate, false)?;
    }

    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(DecreaseSpotPositionQuoteResult {
        decrease_percent,
        collateral_token,
        position_token: new_position_token,
        collateral,
        borrow,
        swap_input_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: PoolTokenFacade, 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 == PoolTokenFacade::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: PoolTokenFacade,
    available_balance: u64,
    leverage: f64,
    new_position_token: PoolTokenFacade,
    reduce_only: bool,
    position_token: PoolTokenFacade,
    position_amount: u64,
    position_debt: u64,
    protocol_fee_rate: u32,
    protocol_fee_rate_on_collateral: u32,
    fusion_pool: FusionPoolFacade,
    tick_arrays: TickArrays,
) -> Result<u64, CoreError> {
    if leverage < 1.0 {
        return Err(INVALID_ARGUMENTS.into());
    }

    if protocol_fee_rate >= HUNDRED_PERCENT {
        return Err(INVALID_ARGUMENTS.into());
    }

    if protocol_fee_rate_on_collateral >= HUNDRED_PERCENT {
        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 == PoolTokenFacade::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 == PoolTokenFacade::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 == PoolTokenFacade::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: u32, 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: u32, 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(all(test, not(feature = "wasm")))]
mod tests {
    use super::*;
    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(PoolTokenFacade::A, 5.0, 0.0, 0.85), Ok(0.0));
        assert_eq!(get_liquidation_price(PoolTokenFacade::A, 0.0, 5.0, 0.85), Ok(0.0));
        assert_eq!(get_liquidation_price(PoolTokenFacade::A, 5.0, 800.0, 0.85), Ok(188.23529411764707));
        assert_eq!(get_liquidation_price(PoolTokenFacade::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,
            PoolTokenFacade::A,
            PoolTokenFacade::A,
            5.0,
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.collateral, 1057165829);
        assert_eq!(quote.borrow, 800000000);
        assert_eq!(quote.estimated_amount, 5_000_000_000);
        assert_eq!(quote.protocol_fee_a, 5285830);
        assert_eq!(quote.protocol_fee_b, 8000000);
        assert_eq!(quote.price_impact, 0.03531617625702754);
        assert_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 * 1000.0) / 200.0), 5.0);
    }

    #[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,
            PoolTokenFacade::B,
            PoolTokenFacade::A,
            5.0,
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.collateral, 1060346869);
        assert_eq!(quote.borrow, 4000000000);
        assert_eq!(quote.estimated_amount, 25_000_000_000);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 45301735);
        assert_eq!(quote.price_impact, 0.22306022789755353);
        assert_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 * 1000.0) / 200.0), 5.0);
    }

    #[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,
            PoolTokenFacade::A,
            PoolTokenFacade::B,
            5.0,
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.collateral, 1060346869);
        assert_eq!(quote.borrow, 4000000000);
        assert_eq!(quote.estimated_amount, 1_000_000_000);
        assert_eq!(quote.protocol_fee_a, 45301735);
        assert_eq!(quote.protocol_fee_b, 0);
        assert_eq!(quote.price_impact, 0.04457228974642513);
        assert_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 / 1000.0) * 200.0), 5.0);
    }

    #[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,
            PoolTokenFacade::B,
            PoolTokenFacade::B,
            5.0,
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.collateral, 1057165829);
        assert_eq!(quote.borrow, 20000000000);
        assert_eq!(quote.estimated_amount, 5000_000_000);
        assert_eq!(quote.protocol_fee_a, 200000000);
        assert_eq!(quote.protocol_fee_b, 5285830);
        assert_eq!(quote.price_impact, 0.17633175413067637);
        assert_eq!(quote.estimated_amount as f64 / (quote.estimated_amount as f64 - (quote.borrow as f64 / 1000.0) * 200.0), 5.0);
    }

    #[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,
            PoolTokenFacade::A,
            1.0,
            true,
            PoolTokenFacade::A,
            5_000_000_000, // A
            0,             // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, PoolTokenFacade::A);
        assert_eq!(quote.position_token, PoolTokenFacade::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,
            PoolTokenFacade::B,
            1.0,
            true,
            PoolTokenFacade::A,
            5_000_000_000, // A
            0,             // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, PoolTokenFacade::B);
        assert_eq!(quote.position_token, PoolTokenFacade::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,
            PoolTokenFacade::A,
            5.0,
            true,
            PoolTokenFacade::A,
            5_000_000_000, // A
            800_000_000,   // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, PoolTokenFacade::A);
        assert_eq!(quote.position_token, PoolTokenFacade::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,
            PoolTokenFacade::A,
            5.0,
            true,
            PoolTokenFacade::A,
            5_000_000_000, // A
            800_000_000,   // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            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,
            PoolTokenFacade::B,
            5.0,
            true,
            PoolTokenFacade::A,
            5_000_000_000, // A
            800_000_000,   // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, 200000);
        assert_eq!(quote.collateral_token, PoolTokenFacade::B);
        assert_eq!(quote.position_token, PoolTokenFacade::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,
            PoolTokenFacade::B,
            5.0,
            true,
            PoolTokenFacade::A,
            5_000_000_000, // A
            800_000_000,   // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            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,
            PoolTokenFacade::A,
            1.0,
            false,
            PoolTokenFacade::A,
            5_000_000_000, // A
            800_000_000,   // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, PoolTokenFacade::A);
        assert_eq!(quote.position_token, PoolTokenFacade::B);
        assert_eq!(quote.collateral, 1005025125);
        assert_eq!(quote.borrow, 0);
        assert_eq!(quote.estimated_amount, 200_000_000);
        assert_eq!(quote.protocol_fee_a, 5025126);
        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,
            PoolTokenFacade::A,
            5.0,
            false,
            PoolTokenFacade::A,
            5_000_000_000, // A
            800_000_000,   // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, PoolTokenFacade::A);
        assert_eq!(quote.position_token, PoolTokenFacade::B);
        assert_eq!(quote.collateral, 211433165);
        assert_eq!(quote.borrow, 800000000);
        assert_eq!(quote.estimated_amount, 200_000_000);
        assert_eq!(quote.protocol_fee_a, 1057166);
        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(
            1_200_000_000,
            PoolTokenFacade::B,
            5.0,
            false,
            PoolTokenFacade::A,
            5_000_000_000, // A
            800_000_000,   // B
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, PoolTokenFacade::B);
        assert_eq!(quote.position_token, PoolTokenFacade::B);
        assert_eq!(quote.collateral, 42286633);
        assert_eq!(quote.borrow, 800_000_000);
        assert_eq!(quote.estimated_amount, 200000000);
        assert_eq!(quote.protocol_fee_a, 0);
        assert_eq!(quote.protocol_fee_b, 8211434);
        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,
            PoolTokenFacade::A,
            1.0,
            false,
            PoolTokenFacade::B,
            1000_000_000, // B
            0,            // A
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, PoolTokenFacade::A);
        assert_eq!(quote.position_token, PoolTokenFacade::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, 5025126);
        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,
            PoolTokenFacade::A,
            5.0,
            false,
            PoolTokenFacade::B,
            1000_000_000,  // B
            4_000_000_000, // A
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, PoolTokenFacade::A);
        assert_eq!(quote.position_token, PoolTokenFacade::A);
        assert_eq!(quote.collateral, 211433165);
        assert_eq!(quote.borrow, 160000000);
        assert_eq!(quote.estimated_amount, 1_000_000_000);
        assert_eq!(quote.protocol_fee_a, 2657166);
        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,
            PoolTokenFacade::B,
            5.0,
            false,
            PoolTokenFacade::B,
            1000_000_000,  // B
            4_000_000_000, // A
            HUNDRED_PERCENT / 100,
            HUNDRED_PERCENT / 200,
            fusion_pool,
            test_tick_arrays(fusion_pool),
        )
        .unwrap();

        assert_eq!(quote.decrease_percent, HUNDRED_PERCENT);
        assert_eq!(quote.collateral_token, PoolTokenFacade::B);
        assert_eq!(quote.position_token, PoolTokenFacade::A);
        assert_eq!(quote.collateral, 42_286_633);
        assert_eq!(quote.borrow, 160000000);
        assert_eq!(quote.estimated_amount, 1_000_000_000);
        assert_eq!(quote.protocol_fee_a, 1600000);
        assert_eq!(quote.protocol_fee_b, 211434);
        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 = PoolTokenFacade::B;
        let position_token = PoolTokenFacade::A;
        let leverage = 1.0;
        let protocol_fee_rate = HUNDRED_PERCENT / 100;
        let protocol_fee_rate_on_collateral = HUNDRED_PERCENT / 200;
        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,
            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 = PoolTokenFacade::B;
        let position_token = PoolTokenFacade::A;
        let leverage = 5.0;
        let protocol_fee_rate = HUNDRED_PERCENT / 100;
        let protocol_fee_rate_on_collateral = HUNDRED_PERCENT / 200;
        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,
            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 = PoolTokenFacade::A;
        let position_token = PoolTokenFacade::A;
        let leverage = 5.0;
        let protocol_fee_rate = HUNDRED_PERCENT / 100;
        let protocol_fee_rate_on_collateral = HUNDRED_PERCENT / 200;
        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,
            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 = PoolTokenFacade::B;
        let position_token = PoolTokenFacade::B;
        let leverage = 5.0;
        let protocol_fee_rate = HUNDRED_PERCENT / 100;
        let protocol_fee_rate_on_collateral = HUNDRED_PERCENT / 200;
        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,
            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 { PoolTokenFacade::A } else { PoolTokenFacade::B };
            let position_token = if i == 0 { PoolTokenFacade::A } else { PoolTokenFacade::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;
            let protocol_fee_rate_on_collateral = HUNDRED_PERCENT / 200;
            let available_balance = 50_000_000_000;

            let tradable_amount = get_tradable_amount(
                collateral_token,
                available_balance,
                leverage,
                if position_token == PoolTokenFacade::A {
                    PoolTokenFacade::B
                } else {
                    PoolTokenFacade::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,
                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 = PoolTokenFacade::A;
        let position_token = PoolTokenFacade::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;
        let protocol_fee_rate_on_collateral = HUNDRED_PERCENT / 200;
        let available_balance = 2_000_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            if position_token == PoolTokenFacade::A {
                PoolTokenFacade::B
            } else {
                PoolTokenFacade::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,
            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 = PoolTokenFacade::B;
        let position_token = PoolTokenFacade::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;
        let protocol_fee_rate_on_collateral = HUNDRED_PERCENT / 200;
        let available_balance = 500_000_000;

        let tradable_amount = get_tradable_amount(
            collateral_token,
            available_balance,
            leverage,
            if position_token == PoolTokenFacade::A {
                PoolTokenFacade::B
            } else {
                PoolTokenFacade::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,
            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);
    }
}