use crate::error::{Result, SdkError};
use crate::types::{SwapDirection, SwapMathResult, SwapType};
#[allow(clippy::manual_div_ceil)]
mod wide {
uint::construct_uint! {
pub(super) struct U256(4);
}
}
use wide::U256;
pub const SWAP_FIXED_POINT_SCALE: u128 = 1_000_000_000_000_000_000;
pub const SWAP_ONE_BPS_FIXED_POINT: u128 = SWAP_FIXED_POINT_SCALE / 10_000;
pub fn ceil_div(numerator: u128, denominator: u128) -> Result<u128> {
if denominator == 0 {
return Err(SdkError::InvalidInput(
"denominator must be positive".into(),
));
}
Ok(numerator.div_ceil(denominator))
}
fn checked_add(left: u128, right: u128) -> Result<u128> {
left.checked_add(right).ok_or(SdkError::MathOverflow)
}
fn checked_sub(left: u128, right: u128) -> Result<u128> {
left.checked_sub(right).ok_or(SdkError::MathOverflow)
}
fn checked_mul(left: u128, right: u128) -> Result<u128> {
left.checked_mul(right).ok_or(SdkError::MathOverflow)
}
fn checked_ceil_div(numerator: u128, denominator: u128) -> Result<u128> {
let rounding = checked_sub(denominator, 1)?;
Ok(checked_add(numerator, rounding)? / denominator)
}
fn pow10(decimals: u8) -> Result<u128> {
if decimals > 38 {
return Err(SdkError::InvalidInput(
"decimals must be an integer from 0 through 38".into(),
));
}
10_u128
.checked_pow(u32::from(decimals))
.ok_or(SdkError::MathOverflow)
}
fn validate_bps(value: u16, label: &str) -> Result<()> {
if value > 10_000 {
return Err(SdkError::InvalidInput(format!(
"{label} must be an integer from 0 through 10000"
)));
}
Ok(())
}
fn mul_div_floor(multiplicand: u128, multiplier: u128, denominator: u128) -> Result<u128> {
if denominator == 0 {
return Err(SdkError::MathOverflow);
}
let high = checked_mul(multiplicand / denominator, multiplier)?;
let low_product = checked_mul(multiplicand % denominator, multiplier)?;
checked_add(high, low_product / denominator)
}
fn mul_div_ceil(multiplicand: u128, multiplier: u128, denominator: u128) -> Result<u128> {
if denominator == 0 {
return Err(SdkError::MathOverflow);
}
let high = checked_mul(multiplicand / denominator, multiplier)?;
let low_product = checked_mul(multiplicand % denominator, multiplier)?;
checked_add(high, checked_ceil_div(low_product, denominator)?)
}
fn fits_u64(value: u128) -> Result<u64> {
u64::try_from(value).map_err(|_| SdkError::MathOverflow)
}
pub fn bps_to_fixed_point(bps: u16) -> Result<u128> {
validate_bps(bps, "bps")?;
checked_mul(u128::from(bps), SWAP_ONE_BPS_FIXED_POINT)
}
pub fn calculate_spread_protocol_fee_rate(
redemption_fee_bps: u16,
discount_rate_bps: u16,
spread_protocol_fees_bps: u16,
) -> Result<u128> {
validate_bps(redemption_fee_bps, "redemptionFeeBps")?;
validate_bps(discount_rate_bps, "discountRateBps")?;
validate_bps(spread_protocol_fees_bps, "spreadProtocolFeesBps")?;
if redemption_fee_bps == 10_000 {
return Err(SdkError::InvalidInput(
"redemptionFeeBps must be less than 10000".into(),
));
}
if spread_protocol_fees_bps == 0 {
return Ok(0);
}
let redemption_fee = bps_to_fixed_point(redemption_fee_bps)?;
let discount_rate = bps_to_fixed_point(discount_rate_bps)?;
let protocol_take_rate = bps_to_fixed_point(spread_protocol_fees_bps)?;
let redemption_multiplier = checked_sub(SWAP_FIXED_POINT_SCALE, redemption_fee)?;
let redemption_side = mul_div_ceil(
SWAP_FIXED_POINT_SCALE,
SWAP_FIXED_POINT_SCALE,
redemption_multiplier,
)?;
let discount_side = checked_sub(SWAP_FIXED_POINT_SCALE, discount_rate)?;
let spread_rate = checked_sub(redemption_side, discount_side)?;
let result = mul_div_ceil(spread_rate, protocol_take_rate, SWAP_FIXED_POINT_SCALE)?;
Ok(result.max(SWAP_ONE_BPS_FIXED_POINT))
}
pub fn calculate_protocol_fee_amount(
quote_amount: u64,
quote_decimals: u8,
fee_token_decimals: u8,
quote_nav: u64,
fee_token_nav: u64,
protocol_fees_bps: u16,
) -> Result<u64> {
validate_bps(protocol_fees_bps, "protocolFeesBps")?;
if protocol_fees_bps == 0 {
return Ok(0);
}
if quote_nav == 0 || fee_token_nav == 0 {
return Err(SdkError::InvalidInput("Invalid NAV".into()));
}
let fee_token_scale = pow10(fee_token_decimals)?;
let quote_scale = pow10(quote_decimals)?;
let numerator = U256::from(quote_amount)
.checked_mul(U256::from(protocol_fees_bps))
.and_then(|value| value.checked_mul(U256::from(quote_nav)))
.and_then(|value| value.checked_mul(U256::from(fee_token_scale)))
.ok_or(SdkError::MathOverflow)?;
let denominator = U256::from(10_000_u64)
.checked_mul(U256::from(fee_token_nav))
.and_then(|value| value.checked_mul(U256::from(quote_scale)))
.ok_or(SdkError::MathOverflow)?;
let rounded_numerator = numerator
.checked_add(denominator)
.and_then(|value| value.checked_sub(U256::one()))
.ok_or(SdkError::MathOverflow)?;
let protocol_fees = rounded_numerator / denominator;
if protocol_fees > U256::from(u64::MAX) {
return Err(SdkError::MathOverflow);
}
Ok(protocol_fees.low_u64())
}
#[allow(clippy::too_many_arguments)]
pub fn calculate_swap_results(
amount: u64,
amount_in_decimals: u8,
amount_out_decimals: u8,
swap_direction: SwapDirection,
swap_type: SwapType,
base_nav: u64,
quote_nav: u64,
pair_fee_bps: u16,
spread_protocol_fee_rate: u128,
) -> Result<SwapMathResult> {
if amount == 0 {
return Err(SdkError::InvalidInput("amount must be positive".into()));
}
if base_nav == 0 || quote_nav == 0 {
return Err(SdkError::InvalidInput("Invalid NAV".into()));
}
validate_bps(pair_fee_bps, "pairFeeBps")?;
let total_fee_rate = checked_add(bps_to_fixed_point(pair_fee_bps)?, spread_protocol_fee_rate)?;
if total_fee_rate >= SWAP_FIXED_POINT_SCALE {
return Err(SdkError::InvalidInput("fees out of range".into()));
}
let fee_multiplier = checked_sub(SWAP_FIXED_POINT_SCALE, total_fee_rate)?;
let amount = u128::from(amount);
let base_nav = u128::from(base_nav);
let quote_nav = u128::from(quote_nav);
let pair_fee_bps = u128::from(pair_fee_bps);
let (
amount_transferred_from_user,
mut amount_out,
protocol_fees,
protocol_fee_basis,
discount_amount,
) = match swap_direction {
SwapDirection::QuoteToBase => {
let normalized_quote_scale = pow10(amount_out_decimals)?;
let amount_in = match swap_type {
SwapType::ExactOut => {
let amount_in = checked_mul(amount, pow10(amount_in_decimals)?)?;
let amount_in =
mul_div_ceil(amount_in, SWAP_FIXED_POINT_SCALE, fee_multiplier)?;
let amount_in = mul_div_ceil(amount_in, base_nav, quote_nav)?;
checked_mul(
checked_ceil_div(amount_in, normalized_quote_scale)?,
normalized_quote_scale,
)?
}
SwapType::ExactIn => checked_mul(amount, normalized_quote_scale)?,
};
let pair_fee_amount = mul_div_ceil(amount_in, pair_fee_bps, 10_000)?;
let protocol_fees =
mul_div_ceil(amount_in, spread_protocol_fee_rate, SWAP_FIXED_POINT_SCALE)?;
let discount_amount = checked_ceil_div(pair_fee_amount, normalized_quote_scale)?;
let total_fee_amount = checked_add(pair_fee_amount, protocol_fees)?;
let amount_in_after_fees = checked_sub(amount_in, total_fee_amount)?;
let amount_out = mul_div_floor(amount_in_after_fees, quote_nav, base_nav)?;
(
amount_in,
amount_out,
checked_ceil_div(protocol_fees, normalized_quote_scale)?,
amount_in / normalized_quote_scale,
discount_amount,
)
}
SwapDirection::BaseToQuote => {
let normalized_input_scale = pow10(amount_out_decimals)?;
let normalized_quote_scale = pow10(amount_in_decimals)?;
let amount_in = match swap_type {
SwapType::ExactOut => {
let amount_in = checked_mul(amount, normalized_quote_scale)?;
let amount_in =
mul_div_ceil(amount_in, SWAP_FIXED_POINT_SCALE, fee_multiplier)?;
let amount_in = mul_div_ceil(amount_in, quote_nav, base_nav)?;
checked_mul(
checked_ceil_div(amount_in, normalized_input_scale)?,
normalized_input_scale,
)?
}
SwapType::ExactIn => checked_mul(amount, normalized_input_scale)?,
};
let amount_out = mul_div_floor(amount_in, base_nav, quote_nav)?;
let pair_fee_amount = mul_div_floor(amount_out, pair_fee_bps, 10_000)?;
let protocol_fees =
mul_div_ceil(amount_out, spread_protocol_fee_rate, SWAP_FIXED_POINT_SCALE)?;
let discounted_amount_out = checked_sub(amount_out, pair_fee_amount)?;
(
amount_in,
checked_sub(discounted_amount_out, protocol_fees)?,
checked_ceil_div(protocol_fees, normalized_quote_scale)?,
discounted_amount_out / normalized_quote_scale,
pair_fee_amount / normalized_quote_scale,
)
}
};
amount_out /= pow10(amount_in_decimals)?;
if swap_type == SwapType::ExactOut {
if amount_out < amount {
return Err(SdkError::InvalidInput("Amount out too low".into()));
}
amount_out = amount;
}
let amount_transferred_from_user = amount_transferred_from_user / pow10(amount_out_decimals)?;
Ok(SwapMathResult {
protocol_fees: fits_u64(protocol_fees)?,
protocol_fee_basis: fits_u64(protocol_fee_basis)?,
discount_amount: fits_u64(discount_amount)?,
amount_in_for_vault: fits_u64(amount_transferred_from_user)?,
amount_out: fits_u64(amount_out)?,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn public_ceiling_division_handles_u128_boundaries() {
assert_eq!(ceil_div(u128::MAX, u128::MAX).unwrap(), 1);
assert_eq!(ceil_div(u128::MAX, 2).unwrap(), 1_u128 << 127);
assert!(ceil_div(1, 0).is_err());
}
#[test]
fn normalized_swap_overflow_is_not_widened_away() {
let swap = |amount| {
calculate_swap_results(
amount,
38,
38,
SwapDirection::QuoteToBase,
SwapType::ExactIn,
1,
1,
0,
0,
)
};
assert_eq!(swap(3).unwrap().amount_out, 3);
assert!(matches!(swap(4), Err(SdkError::MathOverflow)));
assert!(matches!(
calculate_swap_results(
3,
38,
38,
SwapDirection::QuoteToBase,
SwapType::ExactIn,
1,
1,
9_000,
0,
),
Err(SdkError::MathOverflow)
));
}
#[test]
fn discount_rounding_and_fee_basis_depend_on_direction() {
let quote_to_base = calculate_swap_results(
1,
0,
0,
SwapDirection::QuoteToBase,
SwapType::ExactIn,
1,
1,
1,
0,
)
.unwrap();
let base_to_quote = calculate_swap_results(
1,
0,
0,
SwapDirection::BaseToQuote,
SwapType::ExactIn,
1,
1,
1,
0,
)
.unwrap();
assert_eq!(
(quote_to_base.amount_out, quote_to_base.discount_amount),
(0, 1)
);
assert_eq!(
(base_to_quote.amount_out, base_to_quote.discount_amount),
(1, 0)
);
let redemption = calculate_swap_results(
100_000_000,
6,
6,
SwapDirection::BaseToQuote,
SwapType::ExactIn,
1_000_000_000,
1_000_000_000,
1_000,
bps_to_fixed_point(500).unwrap(),
)
.unwrap();
assert_eq!(redemption.protocol_fee_basis, 90_000_000);
assert_eq!(redemption.protocol_fees, 5_000_000);
assert_eq!(redemption.amount_out, 85_000_000);
}
#[test]
fn exact_out_rounds_input_up_and_caps_output() {
let result = calculate_swap_results(
100_000_000,
6,
6,
SwapDirection::QuoteToBase,
SwapType::ExactOut,
1_000_000_000,
2_000_000_000,
1_000,
bps_to_fixed_point(500).unwrap(),
)
.unwrap();
assert_eq!(result.amount_in_for_vault, 58_823_530);
assert_eq!(result.protocol_fee_basis, 58_823_530);
assert_eq!(result.discount_amount, 5_882_353);
assert_eq!(result.protocol_fees, 2_941_177);
assert_eq!(result.amount_out, 100_000_000);
let redemption = calculate_swap_results(
1,
0,
0,
SwapDirection::BaseToQuote,
SwapType::ExactOut,
1,
1,
1,
0,
)
.unwrap();
assert_eq!(redemption.amount_in_for_vault, 2);
assert_eq!(redemption.amount_out, 1);
}
#[test]
fn fee_boundaries_validate_before_applying_minimum_or_shortcuts() {
assert_eq!(calculate_spread_protocol_fee_rate(0, 0, 0).unwrap(), 0);
assert_eq!(
calculate_spread_protocol_fee_rate(0, 0, 500).unwrap(),
SWAP_ONE_BPS_FIXED_POINT
);
assert_eq!(
calculate_spread_protocol_fee_rate(1_000, 1_000, 500).unwrap(),
10_555_555_555_555_556
);
assert!(calculate_spread_protocol_fee_rate(10_000, 0, 0).is_err());
assert!(calculate_spread_protocol_fee_rate(0, 10_001, 0).is_err());
assert!(calculate_swap_results(
1,
0,
0,
SwapDirection::QuoteToBase,
SwapType::ExactIn,
1,
1,
9_999,
SWAP_ONE_BPS_FIXED_POINT,
)
.is_err());
assert!(matches!(
calculate_swap_results(
1,
0,
0,
SwapDirection::QuoteToBase,
SwapType::ExactIn,
1,
1,
1,
SWAP_ONE_BPS_FIXED_POINT,
),
Err(SdkError::MathOverflow)
));
}
#[test]
fn issuer_fee_rounds_only_after_conversion() {
assert_eq!(
calculate_protocol_fee_amount(101, 0, 3, 1, 1, 1).unwrap(),
11
);
assert_eq!(calculate_protocol_fee_amount(1, 6, 6, 1, 1, 1).unwrap(), 1);
assert_eq!(
calculate_protocol_fee_amount(1, 255, 255, 0, 0, 0).unwrap(),
0
);
assert!(calculate_protocol_fee_amount(1, 39, 0, 1, 1, 1).is_err());
}
#[test]
fn issuer_fee_rejects_wide_intermediate_and_result_overflow() {
assert!(matches!(
calculate_protocol_fee_amount(u64::MAX, 0, 38, u64::MAX, 1, 10_000),
Err(SdkError::MathOverflow)
));
assert!(matches!(
calculate_protocol_fee_amount(u64::MAX, 0, 1, 1, 1, 10_000),
Err(SdkError::MathOverflow)
));
assert!(matches!(
calculate_swap_results(
u64::MAX,
0,
0,
SwapDirection::QuoteToBase,
SwapType::ExactIn,
1,
2,
0,
0,
),
Err(SdkError::MathOverflow)
));
}
}