riptide-amm-math 2.0.1

use borsh::{BorshDeserialize, BorshSerialize};
#[cfg(feature = "wasm")]
use riptide_amm_macros::wasm_expose;

use super::{
    super::{
        error::{CoreError, AMOUNT_EXCEEDS_MAX_I32, ARITHMETIC_OVERFLOW},
        quote::QuoteType,
    },
    SingleSideLiquidity, PER_M_DENOMINATOR,
};
use ethnum::U256;

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
#[cfg_attr(true, derive(BorshDeserialize, BorshSerialize))]
#[cfg_attr(feature = "wasm", wasm_expose)]
pub enum SkewExponent {
    Linear,
    Quadratic,
    Cubic,
}

impl SkewExponent {
    pub fn value(&self) -> u32 {
        match self {
            Self::Linear => 1,
            Self::Quadratic => 2,
            Self::Cubic => 3,
        }
    }
}

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
#[cfg_attr(true, derive(BorshDeserialize, BorshSerialize))]
#[cfg_attr(feature = "wasm", wasm_expose)]
pub enum SkewMode {
    None,
    Polynomial {
        exponent: SkewExponent,
        positive_bid_per_m: u32,
        negative_bid_per_m: u32,
        positive_ask_per_m: u32,
        negative_ask_per_m: u32,
    },
}

/// Apply the skew-cliff shift: returns 0 when `deviation` is inside
/// `[skew_cliff_min, skew_cliff_max]` (the dead band between the cliffs),
/// otherwise shifts `deviation` toward zero by the relevant cliff (so the
/// polynomial restarts from zero at the cliff instead of jumping). The
/// caller must validate that `skew_cliff_min ≤ 0 ≤ skew_cliff_max`.
fn apply_skew_cliff(deviation_per_m: i32, skew_cliff_min: i32, skew_cliff_max: i32) -> i32 {
    if deviation_per_m >= skew_cliff_min && deviation_per_m <= skew_cliff_max {
        0
    } else if deviation_per_m > skew_cliff_max {
        deviation_per_m - skew_cliff_max
    } else {
        // deviation_per_m < skew_cliff_min (which is ≤ 0), result is negative
        deviation_per_m - skew_cliff_min
    }
}

/// Run the polynomial skew formula on a (possibly skew-cliff-shifted)
/// deviation.
#[allow(clippy::too_many_arguments)]
fn polynomial_skew(
    deviation_per_m: i32,
    a_to_b: bool,
    exponent: SkewExponent,
    positive_bid_per_m: u32,
    negative_bid_per_m: u32,
    positive_ask_per_m: u32,
    negative_ask_per_m: u32,
) -> Result<i32, CoreError> {
    let intensity = select_intensity(
        deviation_per_m,
        a_to_b,
        positive_bid_per_m,
        negative_bid_per_m,
        positive_ask_per_m,
        negative_ask_per_m,
    );
    let sign = deviation_per_m.signum();
    let abs_dev = deviation_per_m.unsigned_abs() as u128;
    let exp = exponent.value();

    let numerator = abs_dev
        .checked_pow(exp)
        .ok_or(ARITHMETIC_OVERFLOW)?
        .checked_mul(intensity as u128)
        .ok_or(ARITHMETIC_OVERFLOW)?;
    let denominator = (PER_M_DENOMINATOR as u128)
        .checked_pow(exp)
        .ok_or(ARITHMETIC_OVERFLOW)?;

    let quotient = numerator
        .checked_div(denominator)
        .ok_or(ARITHMETIC_OVERFLOW)?;
    let remainder = numerator
        .checked_rem(denominator)
        .ok_or(ARITHMETIC_OVERFLOW)?;
    let abs_result = if remainder > 0 {
        quotient.checked_add(1).ok_or(ARITHMETIC_OVERFLOW)?
    } else {
        quotient
    };

    let result = i32::try_from(abs_result).map_err(|_| AMOUNT_EXCEEDS_MAX_I32)?;
    sign.checked_mul(result).ok_or(ARITHMETIC_OVERFLOW)
}

fn select_intensity(
    deviation_per_m: i32,
    a_to_b: bool,
    positive_bid_per_m: u32,
    negative_bid_per_m: u32,
    positive_ask_per_m: u32,
    negative_ask_per_m: u32,
) -> u32 {
    match (deviation_per_m >= 0, a_to_b) {
        (true, true) => positive_bid_per_m,
        (false, true) => negative_bid_per_m,
        (true, false) => positive_ask_per_m,
        (false, false) => negative_ask_per_m,
    }
}

impl SkewMode {
    /// Computes the skew value in per_m units.
    /// `deviation_per_m` ranges from -1_000_000 to +1_000_000.
    /// Returns the skew adjustment to apply: bid_spread += skew, ask_spread -= skew.
    /// Apply the skew curve to a (possibly skew-cliff-shifted) deviation.
    ///
    /// `skew_cliff_min_per_m` and `skew_cliff_max_per_m` come from the Market
    /// struct (governance-controlled policy). When
    /// `min ≤ deviation ≤ max` the result is zero (dead band between the
    /// cliffs); outside the band, `deviation` is shifted toward zero by the
    /// relevant cliff before the polynomial is applied so the curve restarts
    /// from zero at the cliff instead of jumping. Operators disable the
    /// cliffs by setting both values to zero.
    ///
    /// Validity: `skew_cliff_min_per_m ≤ 0 ≤ skew_cliff_max_per_m`, both in
    /// `(-PER_M_DENOMINATOR, PER_M_DENOMINATOR)`.
    pub(crate) fn compute_skew_per_m(
        &self,
        deviation_per_m: i32,
        quote_type: QuoteType,
        skew_cliff_min_per_m: i32,
        skew_cliff_max_per_m: i32,
    ) -> Result<i32, CoreError> {
        match self {
            Self::None => Ok(0),
            Self::Polynomial {
                exponent,
                positive_bid_per_m,
                negative_bid_per_m,
                positive_ask_per_m,
                negative_ask_per_m,
            } => {
                if skew_cliff_min_per_m > 0
                    || skew_cliff_max_per_m < 0
                    || skew_cliff_min_per_m <= -PER_M_DENOMINATOR
                    || skew_cliff_max_per_m >= PER_M_DENOMINATOR
                {
                    return Err(super::super::error::INVALID_ORACLE_DATA);
                }
                let shifted =
                    apply_skew_cliff(deviation_per_m, skew_cliff_min_per_m, skew_cliff_max_per_m);
                if shifted == 0 {
                    return Ok(0);
                }
                polynomial_skew(
                    shifted,
                    quote_type.a_to_b(),
                    *exponent,
                    *positive_bid_per_m,
                    *negative_bid_per_m,
                    *positive_ask_per_m,
                    *negative_ask_per_m,
                )
            }
        }
    }
}

/// Applies skew to all prices in SingleSideLiquidity.
/// adjusted_price = price * (PER_M - skew_per_m) / PER_M
pub(crate) fn apply_skew_to_liquidity(
    liquidity: SingleSideLiquidity,
    skew_per_m: i32,
    quote_type: QuoteType,
) -> Result<SingleSideLiquidity, CoreError> {
    let clamped = skew_per_m.clamp(-PER_M_DENOMINATOR, PER_M_DENOMINATOR);
    if clamped == 0 {
        return Ok(liquidity);
    }
    let a_to_b = quote_type.a_to_b();
    let widening = a_to_b == (clamped > 0);
    let abs_skew = U256::from(clamped.unsigned_abs());
    let denom = U256::from(PER_M_DENOMINATOR as u64);
    let mut result = SingleSideLiquidity::new();
    for &(price, amount) in liquidity.as_slice() {
        let numerator = U256::from(price)
            .checked_mul(abs_skew)
            .ok_or(ARITHMETIC_OVERFLOW)?;
        let quotient = numerator.checked_div(denom).ok_or(ARITHMETIC_OVERFLOW)?;
        let remainder = numerator.checked_rem(denom).ok_or(ARITHMETIC_OVERFLOW)?;
        let delta: u128 = if widening && remainder > U256::ZERO {
            quotient.checked_add(U256::ONE).ok_or(ARITHMETIC_OVERFLOW)?
        } else {
            quotient
        }
        .try_into()
        .map_err(|_| ARITHMETIC_OVERFLOW)?;
        let adjusted_price = if clamped > 0 {
            price.checked_sub(delta).ok_or(ARITHMETIC_OVERFLOW)?
        } else {
            price.checked_add(delta).ok_or(ARITHMETIC_OVERFLOW)?
        };
        result.push((adjusted_price, amount));
    }
    Ok(result)
}

#[cfg(test)]
mod tests {
    use super::*;
    use rstest::rstest;

    const PRICE_ONE: u128 = 1 << 64;

    #[rstest]
    #[case(SkewMode::None, 200_000, QuoteType::TokenAExactIn, 0)]
    // symmetric Linear
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 500_000, negative_bid_per_m: 500_000, positive_ask_per_m: 500_000, negative_ask_per_m: 500_000 }, 200_000, QuoteType::TokenAExactIn, 100_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 500_000, negative_bid_per_m: 500_000, positive_ask_per_m: 500_000, negative_ask_per_m: 500_000 }, -200_000, QuoteType::TokenAExactIn, -100_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, 1_000_000, QuoteType::TokenAExactIn, 1_000_000)]
    // symmetric Quadratic: 200_000^2 * 1_000_000 / 1_000_000^2 = 40_000
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Quadratic, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, 200_000, QuoteType::TokenAExactIn, 40_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Quadratic, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, -200_000, QuoteType::TokenAExactIn, -40_000)]
    // symmetric Cubic: 200_000^3 * 1_000_000 / 1_000_000^3 = 8_000
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Cubic, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, 200_000, QuoteType::TokenAExactIn, 8_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Cubic, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, -200_000, QuoteType::TokenAExactIn, -8_000)]
    // Cubic at max deviation: 1_000_000^3 * 1_000_000 / 1_000_000^3 = 1_000_000
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Cubic, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, 1_000_000, QuoteType::TokenAExactIn, 1_000_000)]
    // no remainder, no rounding
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, 1, QuoteType::TokenAExactIn, 1)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 1_000_000, negative_bid_per_m: 1_000_000, positive_ask_per_m: 1_000_000, negative_ask_per_m: 1_000_000 }, -1, QuoteType::TokenAExactOut, -1)]
    // 700_001 * 300_000 / 1_000_000 = 210_000.3
    // round up (a_to_b): -> 210_001
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 300_000, negative_bid_per_m: 300_000, positive_ask_per_m: 300_000, negative_ask_per_m: 300_000 }, 700_001, QuoteType::TokenAExactIn, 210_001)]
    // always round away from zero: -> 210_001
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 300_000, negative_bid_per_m: 300_000, positive_ask_per_m: 300_000, negative_ask_per_m: 300_000 }, 700_001, QuoteType::TokenAExactOut, 210_001)]
    // negative deviation: round up -> -210_001
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 300_000, negative_bid_per_m: 300_000, positive_ask_per_m: 300_000, negative_ask_per_m: 300_000 }, -700_001, QuoteType::TokenAExactIn, -210_001)]
    // negative deviation: always round away from zero -> -210_001
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 300_000, negative_bid_per_m: 300_000, positive_ask_per_m: 300_000, negative_ask_per_m: 300_000 }, -700_001, QuoteType::TokenAExactOut, -210_001)]
    // asymmetric Linear: 4 quadrants
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 500_000, QuoteType::TokenAExactIn, 50_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, -500_000, QuoteType::TokenAExactIn, -100_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 500_000, QuoteType::TokenBExactIn, 150_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, -500_000, QuoteType::TokenBExactIn, -200_000)]
    // zero deviation
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 0, QuoteType::TokenAExactIn, 0)]
    // rounding with asymmetric: bid ceil 700_001 * 100_000 / 1_000_000 = 70_000.1 -> 70_001
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 700_001, QuoteType::TokenAExactIn, 70_001)]
    // rounding with asymmetric: always away from zero 700_001 * 300_000 / 1_000_000 = 210_000.3 ->
    // 210_001
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 700_001, QuoteType::TokenBExactIn, 210_001)]
    // one quadrant zero: positive_bid=0 -> skew=0
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Linear, positive_bid_per_m: 0, negative_bid_per_m: 500_000, positive_ask_per_m: 500_000, negative_ask_per_m: 500_000 }, 500_000, QuoteType::TokenAExactIn, 0)]
    // asymmetric Quadratic: 500_000^2 * selected_intensity / 1_000_000^2
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Quadratic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 500_000, QuoteType::TokenAExactIn, 25_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Quadratic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, -500_000, QuoteType::TokenAExactIn, -50_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Quadratic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 500_000, QuoteType::TokenBExactIn, 75_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Quadratic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, -500_000, QuoteType::TokenBExactIn, -100_000)]
    // asymmetric Cubic: 500_000^3 * selected_intensity / 1_000_000^3
    // 500_000^3 = 125_000_000_000_000_000, * 100_000 / 10^18 = 12_500
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Cubic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 500_000, QuoteType::TokenAExactIn, 12_500)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Cubic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, -500_000, QuoteType::TokenAExactIn, -25_000)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Cubic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, 500_000, QuoteType::TokenBExactIn, 37_500)]
    #[case(SkewMode::Polynomial { exponent: SkewExponent::Cubic, positive_bid_per_m: 100_000, negative_bid_per_m: 200_000, positive_ask_per_m: 300_000, negative_ask_per_m: 400_000 }, -500_000, QuoteType::TokenBExactIn, -50_000)]
    fn test_compute_skew_per_m(
        #[case] skew_mode: SkewMode,
        #[case] deviation_per_m: i32,
        #[case] quote_type: QuoteType,
        #[case] expected: i32,
    ) {
        // Skew cliffs = (0, 0) → effectively disabled, behaves like the
        // original Polynomial logic.
        assert_eq!(
            skew_mode
                .compute_skew_per_m(deviation_per_m, quote_type, 0, 0)
                .unwrap(),
            expected
        );
    }

    // Skew-cliff semantics on top of Polynomial: zero inside the band between
    // the cliffs, then shift-from-cliff polynomial outside. Sweeps both
    // symmetric and asymmetric bands.
    #[rstest]
    // Symmetric band [-50k, +50k]: zero at boundary and zero
    #[case(0, -50_000, 50_000, 0)]
    #[case(50_000, -50_000, 50_000, 0)]
    #[case(-50_000, -50_000, 50_000, 0)]
    // Outside the band: shift, linear at full intensity → result = shifted
    #[case(200_000, -50_000, 50_000, 150_000)]
    #[case(-200_000, -50_000, 50_000, -150_000)]
    // Continuity at the cliff: deviation = max + 1 → tiny shift
    #[case(50_001, -50_000, 50_000, 1)]
    // Asymmetric band [-30k, +80k]
    #[case(70_000, -30_000, 80_000, 0)]
    #[case(-30_000, -30_000, 80_000, 0)]
    #[case(130_000, -30_000, 80_000, 50_000)]
    #[case(-130_000, -30_000, 80_000, -100_000)]
    // Wide band acting like SkewMode::None for this deviation
    #[case(500_000, -999_999, 999_999, 0)]
    fn test_compute_skew_per_m_with_skew_cliff(
        #[case] deviation_per_m: i32,
        #[case] skew_cliff_min_per_m: i32,
        #[case] skew_cliff_max_per_m: i32,
        #[case] expected: i32,
    ) {
        let skew = SkewMode::Polynomial {
            exponent: SkewExponent::Linear,
            positive_bid_per_m: 1_000_000,
            negative_bid_per_m: 1_000_000,
            positive_ask_per_m: 1_000_000,
            negative_ask_per_m: 1_000_000,
        };
        assert_eq!(
            skew.compute_skew_per_m(
                deviation_per_m,
                QuoteType::TokenAExactIn,
                skew_cliff_min_per_m,
                skew_cliff_max_per_m,
            )
            .unwrap(),
            expected
        );
    }

    // Invalid skew-cliff configs must be rejected.
    #[rstest]
    // min > 0 — must contain zero
    #[case(10_000, 50_000)]
    // max < 0 — must contain zero
    #[case(-50_000, -10_000)]
    // |min| ≥ PER_M
    #[case(-PER_M_DENOMINATOR, 50_000)]
    // max ≥ PER_M
    #[case(-50_000, PER_M_DENOMINATOR)]
    fn test_compute_skew_per_m_rejects_invalid_skew_cliff(
        #[case] skew_cliff_min_per_m: i32,
        #[case] skew_cliff_max_per_m: i32,
    ) {
        let skew = SkewMode::Polynomial {
            exponent: SkewExponent::Linear,
            positive_bid_per_m: 0,
            negative_bid_per_m: 0,
            positive_ask_per_m: 0,
            negative_ask_per_m: 0,
        };
        let result = skew.compute_skew_per_m(
            100_000,
            QuoteType::TokenAExactIn,
            skew_cliff_min_per_m,
            skew_cliff_max_per_m,
        );
        assert!(result.is_err());
    }

    // SkewMode::None must short-circuit before cliff validation: even invalid
    // cliff configs must still return Ok(0), so disabled skew never affects
    // swap availability.
    #[rstest]
    // valid cliffs
    #[case(0, 0)]
    #[case(-50_000, 50_000)]
    // invalid cliffs that would fail validation for Polynomial
    #[case(10_000, 50_000)]
    #[case(-50_000, -10_000)]
    #[case(-PER_M_DENOMINATOR, 50_000)]
    #[case(-50_000, PER_M_DENOMINATOR)]
    fn test_compute_skew_per_m_none_ignores_skew_cliff(
        #[case] skew_cliff_min_per_m: i32,
        #[case] skew_cliff_max_per_m: i32,
    ) {
        assert_eq!(
            SkewMode::None
                .compute_skew_per_m(
                    500_000,
                    QuoteType::TokenAExactIn,
                    skew_cliff_min_per_m,
                    skew_cliff_max_per_m,
                )
                .unwrap(),
            0
        );
    }

    #[rstest]
    // widening: a_to_b + positive skew, or !a_to_b + negative skew -> ceil delta
    #[case(PRICE_ONE, 0, QuoteType::TokenAExactIn, PRICE_ONE)]
    #[case(PRICE_ONE, 500_000, QuoteType::TokenAExactIn, PRICE_ONE / 2)]
    #[case(PRICE_ONE, -500_000, QuoteType::TokenBExactIn, PRICE_ONE + PRICE_ONE / 2)]
    #[case(PRICE_ONE, 250_000, QuoteType::TokenAExactIn, PRICE_ONE * 3 / 4)]
    #[case(PRICE_ONE, 1_000_000, QuoteType::TokenAExactIn, 0)]
    #[case(PRICE_ONE, -1_000_000, QuoteType::TokenBExactIn, PRICE_ONE * 2)]
    #[case(PRICE_ONE, 2_000_000, QuoteType::TokenAExactIn, 0)] // clamped to 1M
    #[case(PRICE_ONE, -2_000_000, QuoteType::TokenBExactIn, PRICE_ONE * 2)] // clamped to -1M
    // widening: delta ceiling for protocol safety
    #[case(PRICE_ONE, 999_999, QuoteType::TokenAExactIn, PRICE_ONE - (PRICE_ONE * 999_999).div_ceil(1_000_000))]
    #[case(PRICE_ONE, -999_999, QuoteType::TokenBExactIn, PRICE_ONE + (PRICE_ONE * 999_999).div_ceil(1_000_000))]
    // narrowing: a_to_b + negative skew, or !a_to_b + positive skew -> floor delta
    #[case(PRICE_ONE, -999_999, QuoteType::TokenAExactIn, PRICE_ONE + PRICE_ONE * 999_999 / 1_000_000)]
    #[case(PRICE_ONE, 999_999, QuoteType::TokenBExactIn, PRICE_ONE - PRICE_ONE * 999_999 / 1_000_000)]
    fn test_apply_skew_to_liquidity(
        #[case] price: u128,
        #[case] skew_per_m: i32,
        #[case] quote_type: QuoteType,
        #[case] expected_price: u128,
    ) {
        let liquidity = SingleSideLiquidity::from_slice(&[(price, 1000)]);
        let result = apply_skew_to_liquidity(liquidity, skew_per_m, quote_type).unwrap();
        let (result_price, result_amount) = result.as_slice()[0];
        assert_eq!(result_price, expected_price);
        assert_eq!(result_amount, 1000);
    }
}