hylo-core 2.7.3

use fix::prelude::*;

use super::controller::FeeExtract;
use super::interp::FixInterp;
use crate::collateral_ratio::CollateralRatio;
use crate::error::CoreError;

/// Downconvert CR from `N9` unsigned to `N5` signed for curve lookup.
///
/// # Errors
/// * `CollateralRatioConversion` on `i64` overflow.
pub fn narrow_cr(cr: UFix64<N9>) -> Result<IFix64<N5>, CoreError> {
  cr.convert::<N5>()
    .narrow::<i64>()
    .ok_or(CoreError::CollateralRatioConversion)
}

/// Reads a CR out of curve coordinates. Inverse of [`narrow_cr`].
///
/// # Errors
/// * `CollateralRatioConversion` on a negative CR.
pub fn cr_from_curve(cr: IFix64<N5>) -> Result<UFix64<N9>, CoreError> {
  cr.narrow::<u64>()
    .map(UFix64::convert::<N9>)
    .ok_or(CoreError::CollateralRatioConversion)
}

/// Interpolated fee curve controller.
/// Implementors define boundary behavior via `fee_inner`.
pub trait InterpolatedFeeController<const RES: usize> {
  /// Returns a reference to the underlying interpolator.
  fn curve(&self) -> &FixInterp<RES, N5>;

  /// Compute fee for collateral ratio from underlying curve.
  ///
  /// # Errors
  /// * Domain or arithmetic errors
  fn fee_inner(&self, cr: IFix64<N5>) -> Result<IFix64<N5>, CoreError>;

  /// Slope of the fee curve at the given collateral ratio.
  /// Zero on the flat regions outside the curve domain.
  ///
  /// # Errors
  /// * Domain or arithmetic errors
  fn fee_slope(&self, cr: IFix64<N5>) -> Result<IFix64<N5>, CoreError>;

  /// Fee rate for a collateral ratio from the underlying curve.
  ///
  /// # Errors
  /// * Domain or fee conversion
  fn fee_rate(&self, cr: CollateralRatio) -> Result<UFix64<N5>, CoreError> {
    self
      .fee_inner(cr.fee_curve_x())?
      .narrow()
      .ok_or(CoreError::InterpFeeConversion)
  }

  /// Applies the interpolated fee to an input amount.
  ///
  /// # Errors
  /// * Domain or fee extraction arithmetic
  fn apply_fee<InExp>(
    &self,
    cr: CollateralRatio,
    amount_in: UFix64<InExp>,
  ) -> Result<FeeExtract<InExp>, CoreError> {
    FeeExtract::new(self.fee_rate(cr)?, amount_in)
  }
}

#[derive(Clone)]
pub struct InterpolatedMintFees {
  curve: FixInterp<21, N5>,
}

impl InterpolatedMintFees {
  #[must_use]
  pub fn new(curve: FixInterp<21, N5>) -> InterpolatedMintFees {
    InterpolatedMintFees { curve }
  }
}

impl InterpolatedFeeController<21> for InterpolatedMintFees {
  fn curve(&self) -> &FixInterp<21, N5> {
    &self.curve
  }

  fn fee_inner(&self, cr: IFix64<N5>) -> Result<IFix64<N5>, CoreError> {
    let interp = self.curve();
    if cr < interp.x_min() {
      Err(CoreError::NoValidStablecoinMintFee)
    } else {
      interp.saturating_interpolate(cr)
    }
  }

  fn fee_slope(&self, cr: IFix64<N5>) -> Result<IFix64<N5>, CoreError> {
    let interp = self.curve();
    if cr < interp.x_min() {
      Err(CoreError::NoValidStablecoinMintFee)
    } else if cr > interp.x_max() || interp.is_saturated(cr)? {
      Ok(IFix64::zero())
    } else {
      interp.derivative(cr)
    }
  }
}

#[derive(Clone)]
pub struct InterpolatedRedeemFees {
  curve: FixInterp<11, N5>,
}

impl InterpolatedRedeemFees {
  #[must_use]
  pub fn new(curve: FixInterp<11, N5>) -> InterpolatedRedeemFees {
    InterpolatedRedeemFees { curve }
  }

  /// Fee rate at `cr`, saturating at `y_max`.
  ///
  /// # Errors
  /// * Interpolation or fee conversion
  #[cfg(feature = "offchain")]
  pub fn saturating_fee_rate(
    &self,
    cr: CollateralRatio,
  ) -> Result<UFix64<N5>, CoreError> {
    self
      .fee_inner(cr.fee_curve_x().min(self.curve.x_max()))?
      .narrow()
      .ok_or(CoreError::InterpFeeConversion)
  }
}

impl InterpolatedFeeController<11> for InterpolatedRedeemFees {
  fn curve(&self) -> &FixInterp<11, N5> {
    &self.curve
  }

  fn fee_inner(&self, cr: IFix64<N5>) -> Result<IFix64<N5>, CoreError> {
    let interp = self.curve();
    if cr < interp.x_min() {
      Ok(interp.y_min())
    } else if cr > interp.x_max() {
      Err(CoreError::NoValidStablecoinRedeemFee)
    } else {
      interp.interpolate(cr)
    }
  }

  fn fee_slope(&self, cr: IFix64<N5>) -> Result<IFix64<N5>, CoreError> {
    let interp = self.curve();
    if cr > interp.x_max() {
      Err(CoreError::NoValidStablecoinRedeemFee)
    } else if cr < interp.x_min() || interp.is_saturated(cr)? {
      Ok(IFix64::zero())
    } else {
      interp.derivative(cr)
    }
  }
}

#[cfg(test)]
mod tests {
  use anyhow::Result;
  use fix::typenum::Integer;
  use proptest::prelude::*;
  use proptest::test_runner::TestCaseResult;

  use super::*;
  use crate::collateral_ratio::CR;
  use crate::error::CoreError;
  use crate::fees::curves::{MINT_FEE_INV, REDEEM_FEE_LN};
  use crate::util::proptest::*;

  fn collateral_ratio() -> BoxedStrategy<CollateralRatio> {
    (0u64..4_000_000_000u64)
      .prop_map(|bits| CR::Finite(UFix64::new(bits)))
      .boxed()
  }

  fn redeem_domain_collateral_ratio() -> BoxedStrategy<CollateralRatio> {
    (0u64..=1_500_000_000u64)
      .prop_map(|bits| CR::Finite(UFix64::new(bits)))
      .boxed()
  }

  fn mint_fees() -> InterpolatedMintFees {
    let curve = FixInterp::from_points_unchecked(*MINT_FEE_INV);
    InterpolatedMintFees::new(curve)
  }

  fn redeem_fees() -> InterpolatedRedeemFees {
    let curve = FixInterp::from_points_unchecked(*REDEEM_FEE_LN);
    InterpolatedRedeemFees::new(curve)
  }

  fn assert_conservation<Exp: Integer>(
    extract: &FeeExtract<Exp>,
    amount: UFix64<Exp>,
    cr: CollateralRatio,
  ) -> TestCaseResult {
    prop_assert_eq!(
      extract
        .fees_extracted
        .checked_add(&extract.amount_remaining),
      Some(amount),
      "Fee conservation violated at CR {:?}",
      cr,
    );
    Ok(())
  }

  fn assert_mint_fee<Exp: Integer>(
    cr: CollateralRatio,
    amount: UFix64<Exp>,
  ) -> TestCaseResult {
    let fees = mint_fees();
    let cr_n5 = cr.fee_curve_x();
    match fees.apply_fee(cr, amount) {
      Ok(extract) => assert_conservation(&extract, amount, cr),
      Err(e) => {
        prop_assert!(
          cr_n5 < fees.curve().x_min()
            && e == CoreError::NoValidStablecoinMintFee,
          "Mint fee rejected in-domain CR {:?}: {}",
          cr,
          e,
        );
        Ok(())
      }
    }
  }

  fn assert_redeem_fee<Exp: Integer>(
    cr: CollateralRatio,
    amount: UFix64<Exp>,
  ) -> TestCaseResult {
    let fees = redeem_fees();
    let cr_n5 = cr.fee_curve_x();
    match fees.apply_fee(cr, amount) {
      Ok(extract) => assert_conservation(&extract, amount, cr),
      Err(e) => {
        prop_assert!(
          cr_n5 > fees.curve().x_max()
            && e == CoreError::NoValidStablecoinRedeemFee,
          "Redeem fee rejected in-domain CR {:?}: {}",
          cr,
          e,
        );
        Ok(())
      }
    }
  }

  #[test]
  fn redeem_fee_rejected_above_curve_domain() {
    let fees = redeem_fees();
    let cr = IFix64::<N5>::constant(150_001);
    assert_eq!(
      fees.fee_inner(cr).err(),
      Some(CoreError::NoValidStablecoinRedeemFee)
    );
    assert_eq!(
      fees.fee_slope(cr).err(),
      Some(CoreError::NoValidStablecoinRedeemFee)
    );
  }

  #[test]
  fn redeem_fee_maximal_at_domain_edge() -> Result<()> {
    let fees = redeem_fees();
    let cr = IFix64::<N5>::constant(150_000);
    assert_eq!(fees.fee_inner(cr)?, fees.curve().y_max());
    Ok(())
  }

  #[cfg(feature = "offchain")]
  #[test]
  fn saturating_fee_rate_equals_strict_inside_domain() -> Result<()> {
    let fees = redeem_fees();
    let cr = CR::Finite(UFix64::new(1_300_000_000));
    assert_eq!(fees.saturating_fee_rate(cr)?, fees.fee_rate(cr)?);
    Ok(())
  }

  #[cfg(feature = "offchain")]
  #[test]
  fn saturating_fee_rate_holds_edge_above_domain() -> Result<()> {
    let fees = redeem_fees();
    let edge = fees.fee_rate(CR::Finite(UFix64::new(1_500_000_000)))?;
    let above = CR::Finite(UFix64::new(3_000_000_000));
    assert_eq!(
      fees.fee_rate(above).err(),
      Some(CoreError::NoValidStablecoinRedeemFee)
    );
    assert_eq!(fees.saturating_fee_rate(above)?, edge);
    assert_eq!(fees.saturating_fee_rate(CR::Infinite)?, edge);
    Ok(())
  }

  #[test]
  fn mint_slope_zero_where_fee_pinned() -> Result<()> {
    let fees = mint_fees();
    let pinned = IFix64::<N5>::constant(150_001);
    assert_eq!(fees.fee_inner(pinned)?, fees.curve().y_min());
    assert_eq!(fees.fee_slope(pinned)?, IFix64::zero());
    let interior = IFix64::<N5>::constant(150_500);
    assert!(fees.fee_slope(interior)? < IFix64::zero());
    Ok(())
  }

  proptest! {
    #[test]
    fn mint_apply_fee_lst(
      cr in collateral_ratio(),
      amount in lst_amount(),
    ) {
      assert_mint_fee(cr, amount)?;
    }

    #[test]
    fn mint_apply_fee_token(
      cr in collateral_ratio(),
      amount in token_amount(),
    ) {
      assert_mint_fee(cr, amount)?;
    }

    #[test]
    fn redeem_apply_fee_lst(
      cr in collateral_ratio(),
      amount in lst_amount(),
    ) {
      assert_redeem_fee(cr, amount)?;
    }

    #[test]
    fn redeem_apply_fee_token(
      cr in collateral_ratio(),
      amount in token_amount(),
    ) {
      assert_redeem_fee(cr, amount)?;
    }

    #[test]
    fn mint_fee_decreases_with_cr(
      cr_a in collateral_ratio(),
      cr_b in collateral_ratio(),
      amount in lst_amount(),
    ) {
      let (cr_high, cr_low) = if cr_a > cr_b {
        (cr_a, cr_b)
      } else {
        (cr_b, cr_a)
      };
      prop_assume!(cr_high > cr_low);

      let fees = mint_fees();
      if let (Ok(high), Ok(low)) = (
        fees.apply_fee(cr_high, amount),
        fees.apply_fee(cr_low, amount),
      ) {
        prop_assert!(
          high.fees_extracted <= low.fees_extracted,
          "fee({cr_high:?}) = {:?} > fee({cr_low:?}) = {:?}",
          high.fees_extracted, low.fees_extracted,
        );
      } else {
        Err(TestCaseError::reject("CR below threshold"))?;
      }
    }

    #[test]
    fn redeem_fee_increases_with_cr(
      cr_a in redeem_domain_collateral_ratio(),
      cr_b in redeem_domain_collateral_ratio(),
      amount in lst_amount(),
    ) {
      let (cr_high, cr_low) = if cr_a > cr_b {
        (cr_a, cr_b)
      } else {
        (cr_b, cr_a)
      };
      prop_assume!(cr_high > cr_low);

      let fees = redeem_fees();
      if let (Ok(high), Ok(low)) = (
        fees.apply_fee(cr_high, amount),
        fees.apply_fee(cr_low, amount),
      ) {
        prop_assert!(
          high.fees_extracted >= low.fees_extracted,
          "fee({cr_high:?}) = {:?} < fee({cr_low:?}) = {:?}",
          high.fees_extracted, low.fees_extracted,
        );
      } else {
        Err(TestCaseError::reject("CR above redeem curve domain"))?;
      }
    }
  }
}