use alloy::primitives::{U256, U512};
use serde::{Deserialize, Serialize};
use tycho_common::simulation::errors::SimulationError;
use crate::evm::protocol::{u256_num::u256_to_f64, utils::solidity_math::mul_div};
pub(super) const MAX_KNOTS: usize = 36;
const WAD: U256 = U256::from_limbs([1_000_000_000_000_000_000, 0, 0, 0]);
const BPS: U256 = U256::from_limbs([10_000, 0, 0, 0]);
pub(super) fn invalid(reason: impl std::fmt::Display) -> SimulationError {
SimulationError::InvalidInput(format!("BaiBai: {reason}"), None)
}
fn add(a: U256, b: U256) -> Result<U256, SimulationError> {
a.checked_add(b)
.ok_or_else(|| invalid("uint256 addition overflow"))
}
fn mul(a: U256, b: U256) -> Result<U256, SimulationError> {
a.checked_mul(b)
.ok_or_else(|| invalid("uint256 multiplication overflow"))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Knot {
pub q: u64,
pub extra: u64,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Side {
pub spread_bps: i16,
pub depth_bps: u16,
pub filled: U256,
pub knots: Vec<Knot>,
}
#[derive(Debug)]
pub(super) struct Curve {
price: U256,
pub(super) filled: U256,
max: U256,
knots: Vec<(U256, U256)>,
asks: bool,
}
impl Curve {
pub(super) fn new(
side: &Side,
mid: U256,
q_unit: U256,
c_unit: U256,
asks: bool,
) -> Result<Self, SimulationError> {
if side.knots.len() > MAX_KNOTS || side.spread_bps <= -10_000 || side.depth_bps > 10_000 {
return Err(invalid("invalid curve parameters"));
}
let mut knots: Vec<(U256, U256)> = Vec::with_capacity(side.knots.len());
for knot in &side.knots {
let q = mul(U256::from(knot.q), q_unit)?;
let c = mul(U256::from(knot.extra), c_unit)?;
let (prev_q, prev_c) = knots
.last()
.copied()
.unwrap_or((U256::ZERO, U256::ZERO));
if q <= prev_q || c < prev_c {
return Err(invalid("nonmonotonic knots"));
}
knots.push((q, c));
}
let last_q = knots
.last()
.map_or(U256::ZERO, |knot| knot.0);
let max = mul(last_q, U256::from(side.depth_bps))? / BPS;
let scale = U256::from((10_000 + i32::from(side.spread_bps)).cast_unsigned());
Ok(Curve { price: mul(mid, scale)? / BPS, filled: side.filled, max, knots, asks })
}
fn extra(prev: (U256, U256), end: (U256, U256), x: U256) -> Result<U256, SimulationError> {
add(prev.1, mul(end.1 - prev.1, x - prev.0)?.div_ceil(end.0 - prev.0))
}
fn extra_at(&self, x: U256) -> Result<U256, SimulationError> {
let mut prev = (U256::ZERO, U256::ZERO);
for &end in &self.knots {
if x <= end.0 {
return Self::extra(prev, end, x);
}
prev = end;
}
Ok(prev.1)
}
fn cost(
&self,
prev: (U256, U256),
end: (U256, U256),
from: U256,
to: U256,
) -> Result<U256, SimulationError> {
Ok(add(mul(self.price, to - from)?.div_ceil(WAD), Self::extra(prev, end, to)?)? -
Self::extra(prev, end, from)?)
}
pub(super) fn capacity(&self) -> Result<U256, SimulationError> {
if self.filled >= self.max {
return Ok(U256::ZERO);
}
let mut total = U256::ZERO;
let mut q = self.filled;
let mut prev = (U256::ZERO, U256::ZERO);
for &end in &self.knots {
if end.0 > q {
if !self.asks &&
U512::from(self.price) * U512::from(end.0 - prev.0) <=
U512::from(end.1 - prev.1) * U512::from(WAD)
{
break;
}
let stop = end.0.min(self.max);
total = if self.asks {
add(total, self.cost(prev, end, q, stop)?)?
} else {
stop - self.filled
};
q = stop;
if q == self.max {
break;
}
}
prev = end;
}
Ok(total)
}
pub(super) fn output_bound(&self, input: U256) -> Result<U256, SimulationError> {
if self.asks {
return Ok(self.quote(input)?.0);
}
let q = add(self.filled, input)?;
let mid = mul(self.price, input)?;
let mut prev = (U256::ZERO, U256::ZERO);
for &end in &self.knots {
if q <= end.0 {
let span = end.0 - prev.0;
let remainder = mul(end.1 - prev.1, q - prev.0)? % span;
let carry = remainder != U256::ZERO &&
U512::from(mid % WAD) * U512::from(span) >=
U512::from(remainder) * U512::from(WAD);
let extra = Self::extra(prev, end, q)? - self.extra_at(self.filled)?;
return Ok((mid / WAD + U256::from(carry)).saturating_sub(extra));
}
prev = end;
}
Err(invalid("beyond bid depth"))
}
pub(super) fn knots_below(&self, cursor: U256) -> u64 {
self.knots
.iter()
.filter(|(q, _)| *q < cursor)
.count() as u64
}
pub(super) fn quote(&self, input: U256) -> Result<(U256, U256), SimulationError> {
if input == U256::ZERO {
return Ok((U256::ZERO, self.filled));
}
if !self.asks {
if input > self.capacity()? {
return Err(invalid("beyond the bid's paying depth"));
}
let q = add(self.filled, input)?;
let mid = mul(self.price, input)? / WAD;
let extra = self.extra_at(q)? - self.extra_at(self.filled)?;
return Ok((mid.saturating_sub(extra), q));
}
if self.filled >= self.max {
return Err(invalid("beyond ask depth"));
}
let mut q = self.filled;
let mut remaining = input;
let mut prev = (U256::ZERO, U256::ZERO);
for &end in &self.knots {
if end.0 > q {
let stop = end.0.min(self.max);
let cost = self.cost(prev, end, q, stop)?;
if remaining < cost {
let dq = mul_div(remaining, stop - q, cost)?;
if dq == U256::ZERO {
return Ok((U256::ZERO, self.filled));
}
q += dq;
remaining = U256::ZERO;
} else {
remaining -= cost;
q = stop;
}
if remaining == U256::ZERO || q == self.max {
break;
}
}
prev = end;
}
if remaining != U256::ZERO {
return Err(invalid("beyond ask depth"));
}
Ok((q - self.filled, q))
}
pub(super) fn marginal_price(&self) -> Result<f64, SimulationError> {
let mut prev = (U256::ZERO, U256::ZERO);
for &end in &self.knots {
if end.0 > self.filled && self.filled < self.max {
let slope = u256_to_f64(end.1 - prev.1)? / u256_to_f64(end.0 - prev.0)?;
let mid = u256_to_f64(self.price)? / 1e18;
let price = if self.asks { 1.0 / (mid + slope) } else { mid - slope };
if price.is_finite() && price > 0.0 {
return Ok(price);
}
break;
}
prev = end;
}
Err(invalid("no marginal liquidity"))
}
}