defituna_core/quote/

tuna_spot_position.rs

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 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,
    position_token: PoolTokenFacade,
    leverage: f64,
    position_amount: u64,
    position_debt: u64,
    reduce_only: bool,
    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,
    position_token: PoolTokenFacade,
    position_amount: u64,
    position_debt: u64,
    reduce_only: bool,
    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::*;

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