1use std::{
12 any::Any,
13 collections::HashMap,
14 time::{SystemTime, UNIX_EPOCH},
15};
16
17use alloy::primitives::{U256, U512};
18use num_bigint::{BigUint, ToBigUint};
19use num_traits::Euclid;
20use serde::{Deserialize, Serialize};
21use thiserror::Error;
22use tracing::trace;
23use tycho_common::{
24 dto::ProtocolStateDelta,
25 models::token::Token,
26 simulation::{
27 errors::{SimulationError, TransitionError},
28 protocol_sim::{
29 Balances, GetAmountOutResult, PoolSwap, Price, ProtocolSim, QueryPoolSwapParams,
30 SwapConstraint,
31 },
32 },
33 Bytes,
34};
35
36use crate::evm::{
37 engine_db::{create_engine, SHARED_TYCHO_DB},
38 protocol::{
39 fluid::{v1::constant::RESERVES_RESOLVER, vm},
40 safe_math::sqrt_u512,
41 u256_num::{biguint_to_u256, u256_to_biguint, u256_to_f64},
42 utils::add_fee_markup,
43 },
44 query_pool_swap::price_to_f64_with_decimals,
45};
46
47mod constant {
48 use alloy::{hex, primitives::U256};
49
50 pub const MAX_PRICE_DIFF: U256 = U256::from_limbs([5, 0, 0, 0]); pub const MIN_SWAP_LIQUIDITY: U256 = U256::from_limbs([8500, 0, 0, 0]); pub const SIX_DECIMALS: U256 = U256::from_limbs([1000000, 0, 0, 0]); pub const TWO_DECIMALS: U256 = U256::from_limbs([100, 0, 0, 0]); pub const B_I1E18: U256 = U256::from_limbs([0x0DE0B6B3A7640000, 0, 0, 0]); pub const B_I1E27: U256 = U256::from_limbs([0x9fd0803ce8000000, 0x33b2e3c, 0, 0]); pub const DEX_AMOUNT_DECIMALS: i64 = 12;
57 pub const FEE_PERCENT_PRECISION: U256 = U256::from_limbs([10000, 0, 0, 0]);
58 pub const ZERO_ADDRESS: &[u8] = &hex!("0x0000000000000000000000000000000000000000");
59 pub const NATIVE_ADDRESS: &[u8] = &hex!("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE");
60 pub const RESERVES_RESOLVER: &[u8] = &hex!("0xc93876c0eed99645dd53937b25433e311881a27c");
61}
62
63#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
64pub struct FluidV1 {
65 pool_address: Bytes,
66 token0: Token,
67 token1: Token,
68 collateral_reserves: CollateralReserves,
69 debt_reserves: DebtReserves,
70 dex_limits: DexLimits,
71 center_price: U256,
72 fee: U256,
73 sync_time: u64,
74 pool_reserve0: U256,
75 pool_reserve1: U256,
76}
77
78#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
79pub(super) struct CollateralReserves {
80 pub(super) token0_real_reserves: U256,
81 pub(super) token1_real_reserves: U256,
82 pub(super) token0_imaginary_reserves: U256,
83 pub(super) token1_imaginary_reserves: U256,
84}
85
86#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
87pub(super) struct DebtReserves {
88 pub(super) token0_real_reserves: U256,
89 pub(super) token1_real_reserves: U256,
90 pub(super) token0_imaginary_reserves: U256,
91 pub(super) token1_imaginary_reserves: U256,
92}
93
94#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
95pub(super) struct DexLimits {
96 pub(super) borrowable_token0: TokenLimit,
97 pub(super) borrowable_token1: TokenLimit,
98 pub(super) withdrawable_token0: TokenLimit,
99 pub(super) withdrawable_token1: TokenLimit,
100}
101
102#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
103pub(super) struct TokenLimit {
104 pub(super) available: U256,
105 pub(super) expands_to: U256,
106 pub(super) expand_duration: U256,
107}
108
109#[derive(Debug, Error)]
110enum SwapError {
111 #[error("Insufficient reserve: tokenOut amount exceeds reserve")]
112 InsufficientReserve,
113 #[error("Insufficient reserve: tokenOut amount exceeds borrowable limit")]
114 InsufficientBorrowable,
115 #[error("Insufficient reserve: tokenOut amount exceeds withdrawable limit")]
116 InsufficientWithdrawable,
117 #[error("Insufficient reserve: tokenOut amount exceeds max price limit")]
118 InsufficientMaxPrice,
119 #[error("Invalid reserves ratio")]
120 VerifyReservesRatiosInvalid,
121 #[error("No pools are enabled")]
122 NoPoolsEnabled,
123 #[error("InvalidAmountIn: Amount too low")]
124 InvalidAmountIn,
125}
126
127impl From<SwapError> for SimulationError {
128 fn from(value: SwapError) -> Self {
129 Self::FatalError(value.to_string())
130 }
131}
132impl FluidV1 {
133 #[expect(
134 clippy::too_many_arguments,
135 reason = "parameters mirror the Fluid liquidity-layer swap inputs"
136 )]
137 pub(super) fn new(
138 pool_address: &Bytes,
139 token0: &Token,
140 token1: &Token,
141 collateral_reserves: CollateralReserves,
142 debt_reserves: DebtReserves,
143 dex_limits: DexLimits,
144 center_price: U256,
145 fee: U256,
146 sync_time: u64,
147 ) -> Self {
148 let pool_reserve0 = get_max_reserves(
149 token0.decimals,
150 &dex_limits.withdrawable_token0,
151 &dex_limits.borrowable_token0,
152 &collateral_reserves.token0_real_reserves,
153 &debt_reserves.token0_real_reserves,
154 );
155 let pool_reserve1 = get_max_reserves(
156 token1.decimals,
157 &dex_limits.withdrawable_token1,
158 &dex_limits.borrowable_token1,
159 &collateral_reserves.token1_real_reserves,
160 &debt_reserves.token1_real_reserves,
161 );
162
163 let (token0_normalized, token1_normalized) =
166 if FluidV1::normalize_native_address(&token0.address) <
167 FluidV1::normalize_native_address(&token1.address)
168 {
169 (token0.clone(), token1.clone())
170 } else {
171 (token1.clone(), token0.clone())
172 };
173 Self {
174 pool_address: pool_address.clone(),
175 token0: token0_normalized,
176 token1: token1_normalized,
177 collateral_reserves,
178 debt_reserves,
179 dex_limits,
180 center_price,
181 fee,
182 sync_time,
183 pool_reserve0,
184 pool_reserve1,
185 }
186 }
187
188 fn normalize_native_address(address: &Bytes) -> &[u8] {
189 if address == constant::ZERO_ADDRESS {
190 constant::NATIVE_ADDRESS
191 } else {
192 address
193 }
194 }
195
196 fn closed_form_amount_in(
200 &self,
201 target: &Price,
202 token_in: &Token,
203 token_out: &Token,
204 ) -> Option<BigUint> {
205 let (col, debt) = (&self.collateral_reserves, &self.debt_reserves);
206 let sub_pools = if token_in.address == self.token0.address {
207 [
208 (col.token0_imaginary_reserves, col.token1_imaginary_reserves),
209 (debt.token0_imaginary_reserves, debt.token1_imaginary_reserves),
210 ]
211 } else {
212 [
213 (col.token1_imaginary_reserves, col.token0_imaginary_reserves),
214 (debt.token1_imaginary_reserves, debt.token0_imaginary_reserves),
215 ]
216 };
217 let ten_pow = |exponent: i64| U512::from(10u64).pow(U512::from(exponent.unsigned_abs()));
218 let fee_den = U512::from(constant::SIX_DECIMALS);
219 let fee_num = U512::from(constant::SIX_DECIMALS - self.fee);
220
221 let mut ratio_num =
223 U512::try_from_be_slice(&target.numerator.to_bytes_be())?.checked_mul(fee_num)?;
224 let mut ratio_den =
225 U512::try_from_be_slice(&target.denominator.to_bytes_be())?.checked_mul(fee_den)?;
226 let decimals_shift = token_in.decimals as i64 - token_out.decimals as i64;
228 if decimals_shift >= 0 {
229 ratio_num = ratio_num.checked_mul(ten_pow(decimals_shift))?;
230 } else {
231 ratio_den = ratio_den.checked_mul(ten_pow(decimals_shift))?;
232 }
233
234 let mut amount_adjusted = U512::ZERO;
235 for (reserve_in, reserve_out) in sub_pools {
236 let reserve_in = U512::from(reserve_in);
237 let k = reserve_in.checked_mul(U512::from(reserve_out))?;
239 let new_reserve_in = sqrt_u512(
240 k.checked_mul(ratio_den)?
241 .checked_div(ratio_num)?,
242 );
243 amount_adjusted =
244 amount_adjusted.checked_add(new_reserve_in.saturating_sub(reserve_in))?;
245 }
246
247 let dex_shift = token_in.decimals as i64 - constant::DEX_AMOUNT_DECIMALS;
248 let amount_after_fee = if dex_shift >= 0 {
249 amount_adjusted.checked_mul(ten_pow(dex_shift))?
250 } else {
251 amount_adjusted / ten_pow(dex_shift)
252 };
253 let amount_in = amount_after_fee.checked_mul(fee_den)? / fee_num;
254 Some(u256_to_biguint(U256::checked_from_limbs_slice(amount_in.as_limbs())?))
255 }
256
257 fn swap_to_target_price(
260 &self,
261 params: &QueryPoolSwapParams,
262 target: &Price,
263 tolerance: f64,
264 ) -> Result<PoolSwap, SimulationError> {
265 let (token_in, token_out) = (params.token_in(), params.token_out());
266 let spot = self.spot_price(token_in, token_out)?;
267 let target_f64 = price_to_f64_with_decimals(target, token_in.decimals, token_out.decimals)?;
268 if target_f64 > spot {
269 return Err(SimulationError::InvalidInput(
270 format!("Target price {target_f64} is above spot price {spot}"),
271 None,
272 ));
273 }
274 if target_f64 == spot {
275 return Ok(PoolSwap::new(BigUint::ZERO, BigUint::ZERO, self.clone_box(), None));
276 }
277
278 if let Some(amount_in) = self.closed_form_amount_in(target, token_in, token_out) {
281 if let Ok(result) = self.get_amount_out(amount_in.clone(), token_in, token_out) {
282 let new_spot = result
283 .new_state
284 .spot_price(token_in, token_out)?;
285 let lowest = target_f64 * (1.0 - 1e-12);
287 let highest = target_f64 * (1.0 + tolerance) * (1.0 + 1e-12);
288 if (lowest..=highest).contains(&new_spot) {
289 return Ok(PoolSwap::new(amount_in, result.amount, result.new_state, None));
290 }
291 }
292 }
293 crate::evm::query_pool_swap::query_pool_swap(self, params)
294 }
295}
296
297fn decode_block_timestamp(attributes: &HashMap<String, Bytes>) -> Result<u64, TransitionError> {
298 let bytes = attributes
299 .get(vm::BLOCK_TIMESTAMP_ATTRIBUTE)
300 .ok_or_else(|| {
301 TransitionError::MissingAttribute(vm::BLOCK_TIMESTAMP_ATTRIBUTE.to_string())
302 })?;
303 let timestamp = <[u8; 8]>::try_from(bytes.as_ref()).map_err(|_wrong_length| {
304 TransitionError::DecodeError(format!(
305 "{} must be an 8-byte big-endian u64, got {} bytes",
306 vm::BLOCK_TIMESTAMP_ATTRIBUTE,
307 bytes.len()
308 ))
309 })?;
310 Ok(u64::from_be_bytes(timestamp))
311}
312
313#[typetag::serde]
314impl ProtocolSim for FluidV1 {
315 fn fee(&self) -> f64 {
316 let fee = u256_to_f64(self.fee).expect("Fluid fee values are safe to convert");
317 let precision =
318 u256_to_f64(constant::FEE_PERCENT_PRECISION).expect("FEE_PERCENT_PRECISION is safe");
319 fee / precision / 100.0
322 }
323
324 fn spot_price(&self, base: &Token, _quote: &Token) -> Result<f64, SimulationError> {
325 let price_f64 = if !self
326 .collateral_reserves
327 .token0_imaginary_reserves
328 .is_zero()
329 {
330 u256_to_f64(
331 self.collateral_reserves
332 .token1_imaginary_reserves,
333 )? / u256_to_f64(
334 self.collateral_reserves
335 .token0_imaginary_reserves,
336 )?
337 } else {
338 u256_to_f64(
339 self.debt_reserves
340 .token1_imaginary_reserves,
341 )? / u256_to_f64(
342 self.debt_reserves
343 .token0_imaginary_reserves,
344 )?
345 };
346 let oriented_price_f64 =
347 if base.address == self.token0.address { price_f64 } else { 1.0 / price_f64 };
348
349 Ok(add_fee_markup(oriented_price_f64, self.fee()))
350 }
351
352 fn get_amount_out(
353 &self,
354 amount_in: BigUint,
355 token_in: &Token,
356 token_out: &Token,
357 ) -> Result<GetAmountOutResult, SimulationError> {
358 if amount_in == BigUint::from(0u32) {
359 return Ok(GetAmountOutResult {
360 amount: BigUint::from(0u32),
361 gas: BigUint::from(155433u32),
362 new_state: Box::new(self.clone()),
363 });
364 }
365 let zero2one = self.token0.address == token_in.address;
366
367 let (token_in_decimals, token_out_decimals) = (token_in.decimals, token_out.decimals);
368
369 let amount_in = biguint_to_u256(&amount_in);
370 let fee = amount_in * self.fee / constant::SIX_DECIMALS;
371
372 let amount_in_after_fee = amount_in - fee;
373 let amount_in_adjusted = to_adjusted_amount(amount_in_after_fee, token_in_decimals as i64);
374
375 if amount_in_adjusted < constant::SIX_DECIMALS ||
376 amount_in_after_fee < constant::TWO_DECIMALS
377 {
378 return Err(SwapError::InvalidAmountIn.into());
379 }
380 let mut new_col_reserves = self.collateral_reserves.clone();
381 let mut new_debt_reserves = self.debt_reserves.clone();
382 let mut new_limits = self.dex_limits.clone();
383
384 let amount_out = swap_in_adjusted(
385 zero2one,
386 amount_in_adjusted,
387 &mut new_col_reserves,
388 &mut new_debt_reserves,
389 token_out_decimals as i64,
390 &mut new_limits,
391 self.center_price,
392 self.sync_time,
393 )?;
394
395 let reserve = if zero2one { self.pool_reserve1 } else { self.pool_reserve0 };
396 if amount_out > reserve {
397 return Err(SwapError::InsufficientReserve.into());
398 }
399
400 let result = GetAmountOutResult::new(
401 u256_to_biguint(amount_out),
402 155433.to_biguint().expect("infallible"),
403 Box::new(Self {
404 pool_address: self.pool_address.clone(),
405 token0: self.token0.clone(),
406 token1: self.token1.clone(),
407 collateral_reserves: new_col_reserves,
408 debt_reserves: new_debt_reserves,
409 dex_limits: new_limits,
410 center_price: self.center_price,
411 fee: self.fee,
412 sync_time: self.sync_time,
413 pool_reserve0: self.pool_reserve0,
414 pool_reserve1: self.pool_reserve1,
415 }),
416 );
417 Ok(result)
418 }
419
420 fn get_limits(
421 &self,
422 sell_token: Bytes,
423 buy_token: Bytes,
424 ) -> Result<(BigUint, BigUint), SimulationError> {
425 let zero2one = sell_token == self.token0.address;
426
427 let (upper_bound_out, out_decimals, in_decimals) = if zero2one {
428 (
429 to_adjusted_amount(
430 self.dex_limits
431 .withdrawable_token0
432 .available +
433 self.dex_limits
434 .borrowable_token0
435 .available,
436 self.token0.decimals as i64,
437 ),
438 self.token1.decimals,
439 self.token0.decimals,
440 )
441 } else {
442 (
443 to_adjusted_amount(
444 self.dex_limits
445 .withdrawable_token1
446 .available +
447 self.dex_limits
448 .borrowable_token1
449 .available,
450 self.token1.decimals as i64,
451 ),
452 self.token0.decimals,
453 self.token1.decimals,
454 )
455 };
456 if upper_bound_out == U256::ZERO {
457 trace!("Upper bound is zero for {}", self.pool_address);
458 return Ok((BigUint::ZERO, BigUint::ZERO));
459 }
460 let delta = U256::from(10).pow(U256::from(2));
461 let (max_valid, res) = find_max_valid_u256(upper_bound_out, delta, |amount| {
462 let mut col_clone = self.collateral_reserves.clone();
463 let mut debt_clone = self.debt_reserves.clone();
464 let mut limits_clone = self.dex_limits.clone();
465 swap_in_adjusted(
466 zero2one,
467 amount,
468 &mut col_clone,
469 &mut debt_clone,
470 out_decimals as i64,
471 &mut limits_clone,
472 self.center_price,
473 self.sync_time,
474 )
475 });
476 Ok((
477 u256_to_biguint(from_adjusted_amount(max_valid, in_decimals as i64)),
478 u256_to_biguint(res.unwrap_or_else(|| {
479 trace!(
480 "All evaluations errored during limit search for {} -> {}",
481 sell_token,
482 buy_token
483 );
484 U256::ZERO
485 })),
486 ))
487 }
488
489 fn delta_transition(
492 &mut self,
493 delta: ProtocolStateDelta,
494 _tokens: &HashMap<Bytes, Token>,
495 _balances: &Balances,
496 ) -> Result<(), TransitionError> {
497 let state = match delta
498 .updated_attributes
499 .get(vm::POOL_RESERVES_ADJUSTED_ATTRIBUTE)
500 {
501 Some(reserves) => {
502 let sync_time = decode_block_timestamp(&delta.updated_attributes)?;
503 vm::decode_reserves(reserves, sync_time)?
504 }
505 None => {
506 let engine = create_engine(SHARED_TYCHO_DB.clone(), false)?;
507 vm::fetch_pool_state(&self.pool_address, RESERVES_RESOLVER, &engine)?
508 }
509 };
510
511 trace!(?state, "Calling delta transition for {}", &self.pool_address);
512
513 self.collateral_reserves = state.collateral_reserves;
514 self.debt_reserves = state.debt_reserves;
515 self.dex_limits = state.dex_limits;
516 self.center_price = state.center_price;
517 self.fee = state.fee;
518 self.sync_time = state.sync_time;
519
520 self.pool_reserve0 = get_max_reserves(
521 self.token0.decimals,
522 &self.dex_limits.withdrawable_token0,
523 &self.dex_limits.borrowable_token0,
524 &self
525 .collateral_reserves
526 .token0_real_reserves,
527 &self.debt_reserves.token0_real_reserves,
528 );
529 self.pool_reserve1 = get_max_reserves(
530 self.token1.decimals,
531 &self.dex_limits.withdrawable_token1,
532 &self.dex_limits.borrowable_token1,
533 &self
534 .collateral_reserves
535 .token1_real_reserves,
536 &self.debt_reserves.token1_real_reserves,
537 );
538 Ok(())
539 }
540
541 fn clone_box(&self) -> Box<dyn ProtocolSim> {
542 Box::new(self.clone())
543 }
544
545 fn as_any(&self) -> &dyn Any {
546 self
547 }
548
549 fn as_any_mut(&mut self) -> &mut dyn Any {
550 self
551 }
552
553 fn eq(&self, other: &dyn ProtocolSim) -> bool {
554 if let Some(other_state) = other.as_any().downcast_ref::<Self>() {
555 self == other_state
556 } else {
557 false
558 }
559 }
560
561 fn query_pool_swap(&self, params: &QueryPoolSwapParams) -> Result<PoolSwap, SimulationError> {
562 match params.swap_constraint() {
563 SwapConstraint::PoolTargetPrice { target, tolerance, .. } => {
564 self.swap_to_target_price(params, target, *tolerance)
565 }
566 SwapConstraint::TradeLimitPrice { .. } => {
567 crate::evm::query_pool_swap::query_pool_swap(self, params)
568 }
569 }
570 }
571}
572
573pub fn find_max_valid_u256<T, E, F>(upper_bound: U256, delta: U256, mut f: F) -> (U256, Option<T>)
583where
584 F: FnMut(U256) -> Result<T, E>,
585 E: std::fmt::Debug,
586{
587 let mut low = U256::ZERO;
588 let mut high = upper_bound;
589 let mut best = U256::ZERO;
590 let mut best_result: Option<T> = None;
591
592 while high > low + delta {
593 let mid = (low + high) / U256::from(2);
594
595 match f(mid) {
596 Ok(result) => {
597 best = mid;
598 best_result = Some(result);
599 low = mid;
600 }
601 Err(_) => {
602 high = mid;
603 }
604 }
605 }
606
607 (best, best_result)
608}
609
610#[expect(
611 clippy::too_many_arguments,
612 reason = "parameters mirror the Fluid liquidity-layer swap inputs"
613)]
614fn swap_in_adjusted(
615 swap0_to_1: bool,
616 amount_to_swap: U256,
617 col_reserves: &mut CollateralReserves,
618 debt_reserves: &mut DebtReserves,
619 out_decimals: i64,
620 current_limits: &mut DexLimits,
621 center_price: U256,
622 sync_time: u64,
623) -> Result<U256, SwapError> {
624 let (
625 col_reserve_in,
626 col_reserve_out,
627 col_i_reserve_in,
628 col_i_reserve_out,
629 debt_reserve_in,
630 debt_reserve_out,
631 debt_i_reserve_in,
632 debt_i_reserve_out,
633 borrowable,
634 withdrawable,
635 ) = if swap0_to_1 {
636 (
637 col_reserves.token0_real_reserves,
638 col_reserves.token1_real_reserves,
639 col_reserves.token0_imaginary_reserves,
640 col_reserves.token1_imaginary_reserves,
641 debt_reserves.token0_real_reserves,
642 debt_reserves.token1_real_reserves,
643 debt_reserves.token0_imaginary_reserves,
644 debt_reserves.token1_imaginary_reserves,
645 get_expanded_limit(sync_time, ¤t_limits.borrowable_token1),
646 get_expanded_limit(sync_time, ¤t_limits.withdrawable_token1),
647 )
648 } else {
649 (
650 col_reserves.token1_real_reserves,
651 col_reserves.token0_real_reserves,
652 col_reserves.token1_imaginary_reserves,
653 col_reserves.token0_imaginary_reserves,
654 debt_reserves.token1_real_reserves,
655 debt_reserves.token0_real_reserves,
656 debt_reserves.token1_imaginary_reserves,
657 debt_reserves.token0_imaginary_reserves,
658 get_expanded_limit(sync_time, ¤t_limits.borrowable_token0),
659 get_expanded_limit(sync_time, ¤t_limits.withdrawable_token0),
660 )
661 };
662
663 let borrowable = to_adjusted_amount(borrowable, out_decimals);
665 let withdrawable = to_adjusted_amount(withdrawable, out_decimals);
666
667 let col_pool_enabled = col_reserves.token0_real_reserves > U256::ZERO &&
669 col_reserves.token1_real_reserves > U256::ZERO &&
670 col_reserves.token0_imaginary_reserves > U256::ZERO &&
671 col_reserves.token1_imaginary_reserves > U256::ZERO;
672
673 let debt_pool_enabled = debt_reserves.token0_real_reserves > U256::ZERO &&
674 debt_reserves.token1_real_reserves > U256::ZERO &&
675 debt_reserves.token0_imaginary_reserves > U256::ZERO &&
676 debt_reserves.token1_imaginary_reserves > U256::ZERO;
677
678 if !col_pool_enabled && !debt_pool_enabled {
679 return Err(SwapError::NoPoolsEnabled);
680 }
681
682 let a = if col_pool_enabled && debt_pool_enabled {
683 swap_routing_in(
684 amount_to_swap,
685 col_i_reserve_out,
686 col_i_reserve_in,
687 debt_i_reserve_out,
688 debt_i_reserve_in,
689 )
690 } else if debt_pool_enabled {
691 U256::MAX } else if col_pool_enabled {
693 amount_to_swap + U256::ONE } else {
695 return Err(SwapError::NoPoolsEnabled);
696 };
697
698 let (amount_in_collateral, amount_out_collateral, amount_in_debt, amount_out_debt) = if a ==
699 U256::ZERO ||
700 a == U256::MAX
701 {
702 let amount_out_debt = get_amount_out(amount_to_swap, debt_i_reserve_in, debt_i_reserve_out);
704 (U256::ZERO, U256::ZERO, amount_to_swap, amount_out_debt)
705 } else if a >= amount_to_swap {
706 let amount_out_collateral =
708 get_amount_out(amount_to_swap, col_i_reserve_in, col_i_reserve_out);
709 (amount_to_swap, amount_out_collateral, U256::ZERO, U256::ZERO)
710 } else {
711 let amount_in_debt = amount_to_swap - a;
713 let amount_out_debt = get_amount_out(amount_in_debt, debt_i_reserve_in, debt_i_reserve_out);
714 let amount_out_collateral = get_amount_out(a, col_i_reserve_in, col_i_reserve_out);
715 (a, amount_out_collateral, amount_in_debt, amount_out_debt)
716 };
717
718 if amount_out_debt > debt_reserve_out {
719 return Err(SwapError::InsufficientReserve);
720 }
721
722 if amount_out_collateral > col_reserve_out {
723 return Err(SwapError::InsufficientReserve);
724 }
725
726 if amount_out_debt > borrowable {
727 return Err(SwapError::InsufficientBorrowable);
728 }
729
730 if amount_out_collateral > withdrawable {
731 return Err(SwapError::InsufficientWithdrawable);
732 }
733
734 if amount_in_collateral > U256::ZERO {
735 let reserves_ratio_valid = if swap0_to_1 {
736 verify_token1_reserves(
737 col_reserve_in + amount_in_collateral,
738 col_reserve_out - amount_out_collateral,
739 center_price,
740 )
741 } else {
742 verify_token0_reserves(
743 col_reserve_out - amount_out_collateral,
744 col_reserve_in + amount_in_collateral,
745 center_price,
746 )
747 };
748 if !reserves_ratio_valid {
749 return Err(SwapError::VerifyReservesRatiosInvalid);
750 }
751 }
752
753 if amount_in_debt > U256::ZERO {
754 let reserves_ratio_valid = if swap0_to_1 {
755 verify_token1_reserves(
756 debt_reserve_in + amount_in_debt,
757 debt_reserve_out - amount_out_debt,
758 center_price,
759 )
760 } else {
761 verify_token0_reserves(
762 debt_reserve_out - amount_out_debt,
763 debt_reserve_in + amount_in_debt,
764 center_price,
765 )
766 };
767 if !reserves_ratio_valid {
768 return Err(SwapError::VerifyReservesRatiosInvalid);
769 }
770 }
771
772 let (old_price, new_price) = if amount_in_collateral > amount_in_debt {
773 if swap0_to_1 {
774 (
775 col_i_reserve_out * constant::B_I1E27 / col_i_reserve_in,
776 (col_i_reserve_out - amount_out_collateral) * constant::B_I1E27 /
777 (col_i_reserve_in + amount_in_collateral),
778 )
779 } else {
780 (
781 col_i_reserve_in * constant::B_I1E27 / col_i_reserve_out,
782 (col_i_reserve_in + amount_in_collateral) * constant::B_I1E27 /
783 (col_i_reserve_out - amount_out_collateral),
784 )
785 }
786 } else if swap0_to_1 {
787 (
788 debt_i_reserve_out * constant::B_I1E27 / debt_i_reserve_in,
789 (debt_i_reserve_out - amount_out_debt) * constant::B_I1E27 /
790 (debt_i_reserve_in + amount_in_debt),
791 )
792 } else {
793 (
794 debt_i_reserve_in * constant::B_I1E27 / debt_i_reserve_out,
795 (debt_i_reserve_in + amount_in_debt) * constant::B_I1E27 /
796 (debt_i_reserve_out - amount_out_debt),
797 )
798 };
799
800 let price_diff = old_price.abs_diff(new_price);
801 let max_price_diff = old_price * constant::MAX_PRICE_DIFF / constant::TWO_DECIMALS;
802
803 if price_diff > max_price_diff {
804 return Err(SwapError::InsufficientMaxPrice);
805 }
806
807 if amount_in_collateral > U256::ZERO {
808 update_collateral_reserves_and_limits(
809 swap0_to_1,
810 amount_in_collateral,
811 amount_out_collateral,
812 col_reserves,
813 current_limits,
814 out_decimals,
815 );
816 }
817
818 if amount_in_debt > U256::ZERO {
819 update_debt_reserves_and_limits(
820 swap0_to_1,
821 amount_in_debt,
822 amount_out_debt,
823 debt_reserves,
824 current_limits,
825 out_decimals,
826 );
827 }
828
829 Ok(from_adjusted_amount(amount_out_collateral + amount_out_debt, out_decimals))
830}
831
832#[expect(
833 clippy::too_many_arguments,
834 reason = "parameters mirror the Fluid liquidity-layer swap inputs"
835)]
836#[cfg(test)]
837fn swap_out_adjusted(
838 swap0_to_1: bool,
839 amount_to_receive: U256,
840 col_reserves: &mut CollateralReserves,
841 debt_reserves: &mut DebtReserves,
842 in_decimals: i64,
843 out_decimals: i64,
844 current_limits: &mut DexLimits,
845 center_price: U256,
846 sync_time: u64,
847) -> Result<U256, SwapError> {
848 let (
849 col_reserve_in,
850 col_reserve_out,
851 col_i_reserve_in,
852 col_i_reserve_out,
853 debt_reserve_in,
854 debt_reserve_out,
855 debt_i_reserve_in,
856 debt_i_reserve_out,
857 borrowable,
858 withdrawable,
859 ) = if swap0_to_1 {
860 (
861 col_reserves.token0_real_reserves,
862 col_reserves.token1_real_reserves,
863 col_reserves.token0_imaginary_reserves,
864 col_reserves.token1_imaginary_reserves,
865 debt_reserves.token0_real_reserves,
866 debt_reserves.token1_real_reserves,
867 debt_reserves.token0_imaginary_reserves,
868 debt_reserves.token1_imaginary_reserves,
869 get_expanded_limit(sync_time, ¤t_limits.borrowable_token1),
870 get_expanded_limit(sync_time, ¤t_limits.withdrawable_token1),
871 )
872 } else {
873 (
874 col_reserves.token1_real_reserves,
875 col_reserves.token0_real_reserves,
876 col_reserves.token1_imaginary_reserves,
877 col_reserves.token0_imaginary_reserves,
878 debt_reserves.token1_real_reserves,
879 debt_reserves.token0_real_reserves,
880 debt_reserves.token1_imaginary_reserves,
881 debt_reserves.token0_imaginary_reserves,
882 get_expanded_limit(sync_time, ¤t_limits.borrowable_token0),
883 get_expanded_limit(sync_time, ¤t_limits.withdrawable_token0),
884 )
885 };
886
887 let borrowable = to_adjusted_amount(borrowable, out_decimals);
888 let withdrawable = to_adjusted_amount(withdrawable, out_decimals);
889
890 let col_pool_enabled = col_reserves.token0_real_reserves > U256::ZERO &&
891 col_reserves.token1_real_reserves > U256::ZERO &&
892 col_reserves.token0_imaginary_reserves > U256::ZERO &&
893 col_reserves.token1_imaginary_reserves > U256::ZERO;
894
895 let debt_pool_enabled = debt_reserves.token0_real_reserves > U256::ZERO &&
896 debt_reserves.token1_real_reserves > U256::ZERO &&
897 debt_reserves.token0_imaginary_reserves > U256::ZERO &&
898 debt_reserves.token1_imaginary_reserves > U256::ZERO;
899
900 if !col_pool_enabled && !debt_pool_enabled {
901 return Err(SwapError::NoPoolsEnabled);
902 }
903
904 let a = if col_pool_enabled && debt_pool_enabled {
905 swap_routing_out(
906 amount_to_receive,
907 col_i_reserve_out,
908 col_i_reserve_in,
909 debt_i_reserve_out,
910 debt_i_reserve_in,
911 )
912 } else if debt_pool_enabled {
913 U256::MAX
914 } else if col_pool_enabled {
915 amount_to_receive + U256::ONE
916 } else {
917 return Err(SwapError::NoPoolsEnabled);
918 };
919
920 let mut trigger_update_debt_reserves = false;
921 let mut trigger_update_col_reserves = false;
922
923 let (amount_in_collateral, amount_out_collateral, amount_in_debt, amount_out_debt) =
924 if a == U256::ZERO || a == U256::MAX {
925 let amount_in_debt =
926 get_amount_in(amount_to_receive, debt_i_reserve_in, debt_i_reserve_out);
927 if amount_to_receive > debt_reserve_out {
928 return Err(SwapError::InsufficientReserve);
929 }
930
931 trigger_update_debt_reserves = true;
932 (U256::ZERO, U256::ZERO, amount_in_debt, amount_to_receive)
933 } else if a >= amount_to_receive {
934 let amount_in_collateral =
935 get_amount_in(amount_to_receive, col_i_reserve_in, col_i_reserve_out);
936
937 if amount_to_receive > col_reserve_out {
938 return Err(SwapError::InsufficientReserve);
939 }
940
941 trigger_update_col_reserves = true;
942 (amount_in_collateral, amount_to_receive, U256::ZERO, U256::ZERO)
943 } else {
944 let amount_out_collateral = a;
945 let amount_in_collateral =
946 get_amount_in(amount_out_collateral, col_i_reserve_in, col_i_reserve_out);
947 let amount_out_debt = amount_to_receive - amount_out_collateral;
948 let amount_in_debt =
949 get_amount_in(amount_out_debt, debt_i_reserve_in, debt_i_reserve_out);
950
951 if amount_out_debt > debt_reserve_out || amount_out_collateral > col_reserve_out {
952 return Err(SwapError::InsufficientReserve);
953 }
954
955 (amount_in_collateral, amount_out_collateral, amount_in_debt, amount_out_debt)
956 };
957
958 if amount_in_debt > borrowable {
959 return Err(SwapError::InsufficientBorrowable);
960 }
961
962 if amount_in_collateral > withdrawable {
963 return Err(SwapError::InsufficientWithdrawable);
964 }
965
966 if amount_in_collateral > U256::ZERO {
967 let reserves_ratio_valid = if swap0_to_1 {
968 verify_token1_reserves(
969 col_reserve_in + amount_in_collateral,
970 col_reserve_out - amount_out_collateral,
971 center_price,
972 )
973 } else {
974 verify_token0_reserves(
975 col_reserve_out - amount_out_collateral,
976 col_reserve_in + amount_in_collateral,
977 center_price,
978 )
979 };
980 if !reserves_ratio_valid {
981 return Err(SwapError::VerifyReservesRatiosInvalid);
982 }
983 }
984
985 if amount_in_debt > U256::ZERO {
986 let reserves_ratio_valid = if swap0_to_1 {
987 verify_token1_reserves(
988 debt_reserve_in + amount_in_debt,
989 debt_reserve_out - amount_out_debt,
990 center_price,
991 )
992 } else {
993 verify_token0_reserves(
994 debt_reserve_out - amount_out_debt,
995 debt_reserve_in + amount_in_debt,
996 center_price,
997 )
998 };
999 if !reserves_ratio_valid {
1000 return Err(SwapError::VerifyReservesRatiosInvalid);
1001 }
1002 }
1003
1004 let (old_price, new_price) = if amount_in_collateral > amount_in_debt {
1005 if swap0_to_1 {
1006 (
1007 col_i_reserve_out * constant::B_I1E27 / col_i_reserve_in,
1008 (col_i_reserve_out - amount_out_collateral) * constant::B_I1E27 /
1009 (col_i_reserve_in + amount_in_collateral),
1010 )
1011 } else {
1012 (
1013 col_i_reserve_in * constant::B_I1E27 / col_i_reserve_out,
1014 (col_i_reserve_in + amount_in_collateral) * constant::B_I1E27 /
1015 (col_i_reserve_out - amount_out_collateral),
1016 )
1017 }
1018 } else if swap0_to_1 {
1019 (
1020 debt_i_reserve_out * constant::B_I1E27 / debt_i_reserve_in,
1021 (debt_i_reserve_out - amount_out_debt) * constant::B_I1E27 /
1022 (debt_i_reserve_in + amount_in_debt),
1023 )
1024 } else {
1025 (
1026 debt_i_reserve_in * constant::B_I1E27 / debt_i_reserve_out,
1027 (debt_i_reserve_in + amount_in_debt) * constant::B_I1E27 /
1028 (debt_i_reserve_out - amount_out_debt),
1029 )
1030 };
1031
1032 let price_diff = old_price.abs_diff(new_price);
1033 let max_price_diff = old_price * constant::MAX_PRICE_DIFF / constant::TWO_DECIMALS;
1034
1035 if price_diff > max_price_diff {
1036 return Err(SwapError::InsufficientMaxPrice);
1037 }
1038
1039 if trigger_update_col_reserves {
1040 update_collateral_reserves_and_limits(
1041 swap0_to_1,
1042 amount_in_collateral,
1043 amount_out_collateral,
1044 col_reserves,
1045 current_limits,
1046 out_decimals,
1047 );
1048 }
1049
1050 if trigger_update_debt_reserves {
1051 update_debt_reserves_and_limits(
1052 swap0_to_1,
1053 amount_in_debt,
1054 amount_out_debt,
1055 debt_reserves,
1056 current_limits,
1057 out_decimals,
1058 );
1059 }
1060
1061 Ok(from_adjusted_amount(amount_in_collateral + amount_in_debt, in_decimals))
1062}
1063
1064fn swap_routing_in(t: U256, x: U256, y: U256, x2: U256, y2: U256) -> U256 {
1084 let xy_root = (x * y * constant::B_I1E18).root(2);
1085 let x2y2_root = (x2 * y2 * constant::B_I1E18).root(2);
1086
1087 let numerator = y2 * xy_root + t * xy_root - y * x2y2_root;
1088 let denominator = xy_root + x2y2_root;
1089 numerator / denominator
1090}
1091
1092#[cfg(test)]
1099fn swap_routing_out(t: U256, x: U256, y: U256, x2: U256, y2: U256) -> U256 {
1100 let xy_root = (x * y * constant::B_I1E18).root(2);
1101 let x2y2_root = (x2 * y2 * constant::B_I1E18).root(2);
1102
1103 let numerator = t * xy_root + y * x2y2_root - y2 * xy_root;
1104 let denominator = xy_root + x2y2_root;
1105
1106 numerator / denominator
1107}
1108
1109fn get_amount_out(amount_in: U256, i_reserve_in: U256, i_reserve_out: U256) -> U256 {
1110 amount_in * i_reserve_out / (i_reserve_in + amount_in)
1111}
1112
1113#[cfg(test)]
1117fn get_amount_in(amount_out: U256, i_reserve_in: U256, i_reserve_out: U256) -> U256 {
1118 amount_out * i_reserve_in / (i_reserve_out - amount_out)
1119}
1120
1121fn to_adjusted_amount(amount: U256, decimals: i64) -> U256 {
1122 let diff = decimals - constant::DEX_AMOUNT_DECIMALS;
1123 if diff == 0 {
1124 amount
1125 } else if diff > 0 {
1126 amount / ten_pow(diff)
1127 } else {
1128 amount * ten_pow(-diff)
1129 }
1130}
1131
1132fn from_adjusted_amount(adjusted_amount: U256, decimals: i64) -> U256 {
1142 let diff = decimals - constant::DEX_AMOUNT_DECIMALS;
1143
1144 if diff == 0 {
1145 adjusted_amount
1146 } else if diff < 0 {
1147 let divisor = ten_pow(-diff);
1149 adjusted_amount / divisor
1150 } else {
1151 let multiplier = ten_pow(diff);
1153 adjusted_amount * multiplier
1154 }
1155}
1156
1157fn ten_pow(v: i64) -> U256 {
1158 U256::from(10u64).pow(U256::from(u64::try_from(v).expect("ten_pow exponent is non-negative")))
1159}
1160
1161fn verify_token0_reserves(token0_reserves: U256, token1_reserves: U256, price: U256) -> bool {
1178 let numerator = token1_reserves.saturating_mul(constant::B_I1E27);
1179 let denominator = price.saturating_mul(constant::MIN_SWAP_LIQUIDITY);
1180 token0_reserves >=
1181 numerator
1182 .checked_div(denominator)
1183 .unwrap_or(U256::ZERO)
1184}
1185
1186fn verify_token1_reserves(token0_reserves: U256, token1_reserves: U256, price: U256) -> bool {
1203 let numerator = token0_reserves.saturating_mul(price);
1204 let denominator = constant::B_I1E27.saturating_mul(constant::MIN_SWAP_LIQUIDITY);
1205 token1_reserves >= numerator.div_euclid(&denominator)
1206}
1207
1208fn get_expanded_limit(sync_time: u64, limit: &TokenLimit) -> U256 {
1220 let current_time = SystemTime::now()
1221 .duration_since(UNIX_EPOCH)
1222 .expect("system time before UNIX_EPOCH")
1223 .as_secs();
1224
1225 let elapsed_time = current_time.saturating_sub(sync_time);
1226 let elapsed = U256::from(elapsed_time);
1227
1228 if elapsed_time < 10 {
1229 return limit.available;
1231 }
1232
1233 if elapsed >= limit.expand_duration {
1234 return limit.expands_to;
1236 }
1237
1238 let delta = limit
1241 .expands_to
1242 .saturating_sub(limit.available);
1243 limit
1244 .available
1245 .saturating_add(delta.saturating_mul(elapsed) / limit.expand_duration)
1246}
1247
1248fn update_collateral_reserves_and_limits(
1253 swap0_to_1: bool,
1254 amount_in: U256,
1255 amount_out: U256,
1256 col_reserves: &mut CollateralReserves,
1257 limits: &mut DexLimits,
1258 out_decimals: i64,
1259) {
1260 let unadjusted_amount_out = from_adjusted_amount(amount_out, out_decimals);
1261
1262 if swap0_to_1 {
1263 col_reserves.token0_real_reserves = col_reserves
1265 .token0_real_reserves
1266 .saturating_add(amount_in);
1267 col_reserves.token0_imaginary_reserves = col_reserves
1268 .token0_imaginary_reserves
1269 .saturating_add(amount_in);
1270 col_reserves.token1_real_reserves = col_reserves
1271 .token1_real_reserves
1272 .saturating_sub(amount_out);
1273 col_reserves.token1_imaginary_reserves = col_reserves
1274 .token1_imaginary_reserves
1275 .saturating_sub(amount_out);
1276
1277 limits.withdrawable_token1.available = limits
1278 .withdrawable_token1
1279 .available
1280 .saturating_sub(unadjusted_amount_out);
1281 limits.withdrawable_token1.expands_to = limits
1282 .withdrawable_token1
1283 .expands_to
1284 .saturating_sub(unadjusted_amount_out);
1285 } else {
1286 col_reserves.token0_real_reserves = col_reserves
1288 .token0_real_reserves
1289 .saturating_sub(amount_out);
1290 col_reserves.token0_imaginary_reserves = col_reserves
1291 .token0_imaginary_reserves
1292 .saturating_sub(amount_out);
1293 col_reserves.token1_real_reserves = col_reserves
1294 .token1_real_reserves
1295 .saturating_add(amount_in);
1296 col_reserves.token1_imaginary_reserves = col_reserves
1297 .token1_imaginary_reserves
1298 .saturating_add(amount_in);
1299
1300 limits.withdrawable_token0.available = limits
1301 .withdrawable_token0
1302 .available
1303 .saturating_sub(unadjusted_amount_out);
1304 limits.withdrawable_token0.expands_to = limits
1305 .withdrawable_token0
1306 .expands_to
1307 .saturating_sub(unadjusted_amount_out);
1308 }
1309}
1310
1311fn update_debt_reserves_and_limits(
1312 swap0_to1: bool,
1313 amount_in: U256,
1314 amount_out: U256,
1315 debt_reserves: &mut DebtReserves,
1316 limits: &mut DexLimits,
1317 out_decimals: i64,
1318) {
1319 let unadjusted_amount_out = from_adjusted_amount(amount_out, out_decimals);
1320
1321 if swap0_to1 {
1322 debt_reserves.token0_real_reserves += amount_in;
1323 debt_reserves.token0_imaginary_reserves += amount_in;
1324 debt_reserves.token1_real_reserves -= amount_out;
1325 debt_reserves.token1_imaginary_reserves -= amount_out;
1326
1327 limits.borrowable_token1.available -= unadjusted_amount_out;
1336 limits.borrowable_token1.expands_to -= unadjusted_amount_out;
1337 } else {
1338 debt_reserves.token0_real_reserves -= amount_out;
1339 debt_reserves.token0_imaginary_reserves -= amount_out;
1340 debt_reserves.token1_real_reserves += amount_in;
1341 debt_reserves.token1_imaginary_reserves += amount_in;
1342
1343 limits.borrowable_token0.available -= unadjusted_amount_out;
1344 limits.borrowable_token0.expands_to -= unadjusted_amount_out;
1345 }
1346}
1347
1348fn get_max_reserves(
1349 decimals: u32,
1350 withdrawable_limit: &TokenLimit,
1351 borrowable_limit: &TokenLimit,
1352 real_col_reserves: &U256,
1353 real_debt_reserves: &U256,
1354) -> U256 {
1355 let mut max_limit_reserves = borrowable_limit.expands_to;
1357
1358 if borrowable_limit.expands_to != withdrawable_limit.expands_to {
1359 max_limit_reserves += withdrawable_limit.expands_to;
1360 }
1361
1362 let mut max_real_reserves = *real_col_reserves + *real_debt_reserves;
1364
1365 let decimals_shift = i64::from(decimals) - constant::DEX_AMOUNT_DECIMALS;
1366 if decimals_shift > 0 {
1367 max_real_reserves *= ten_pow(decimals_shift);
1368 } else if decimals_shift < 0 {
1369 max_real_reserves /= ten_pow(-decimals_shift);
1370 }
1371
1372 if max_real_reserves < max_limit_reserves {
1374 max_real_reserves
1375 } else {
1376 max_limit_reserves
1377 }
1378}
1379
1380#[cfg(test)]
1381mod test {
1382 use std::str::FromStr;
1383
1384 use alloy::primitives::I256;
1385 use anyhow::bail;
1386 use num_traits::Num;
1387 use rstest::rstest;
1388 use tycho_common::models::Chain;
1389
1390 use super::*;
1391 use crate::evm::query_pool_swap::test_helpers::{target_price_params, to_price};
1392
1393 fn setup_fluid_pool(center_price: U256) -> (Token, Token, FluidV1) {
1394 let wsteth = Token::new(
1395 &Bytes::from_str("0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0").unwrap(),
1396 "wsteth",
1397 18,
1398 0,
1399 &[Some(20000)],
1400 Chain::Ethereum,
1401 100,
1402 );
1403 let eth = Token::new(
1404 &Bytes::from_str("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE").unwrap(),
1405 "ETH",
1406 18,
1407 0,
1408 &[Some(2000)],
1409 Chain::Ethereum,
1410 100,
1411 );
1412
1413 let pool = FluidV1::new(
1414 &Bytes::from_str("0x0B1a513ee24972DAEf112bC777a5610d4325C9e7").unwrap(),
1415 &wsteth,
1416 ð,
1417 CollateralReserves {
1418 token0_real_reserves: U256::from_str("2169934539358").unwrap(),
1419 token1_real_reserves: U256::from_str("19563846299171").unwrap(),
1420 token0_imaginary_reserves: U256::from_str("62490032619260838").unwrap(),
1421 token1_imaginary_reserves: U256::from_str("73741038977020279").unwrap(),
1422 },
1423 DebtReserves {
1424 token0_real_reserves: U256::from_str("2169108220421").unwrap(),
1425 token1_real_reserves: U256::from_str("19572550738602").unwrap(),
1426 token0_imaginary_reserves: U256::from_str("62511862774117387").unwrap(),
1427 token1_imaginary_reserves: U256::from_str("73766803277429176").unwrap(),
1428 },
1429 limits_wide(),
1430 center_price,
1431 U256::from_str("100").unwrap(),
1432 SystemTime::now()
1433 .duration_since(UNIX_EPOCH)
1434 .unwrap()
1435 .as_secs() -
1436 10,
1437 );
1438 (wsteth, eth, pool)
1439 }
1440
1441 fn limits_wide() -> DexLimits {
1442 let limit_wide = U256::from_str("34242332879776515083099999").unwrap();
1443 DexLimits {
1444 withdrawable_token0: TokenLimit {
1445 available: limit_wide,
1446 expands_to: limit_wide,
1447 expand_duration: U256::ZERO,
1448 },
1449 withdrawable_token1: TokenLimit {
1450 available: limit_wide,
1451 expands_to: limit_wide,
1452 expand_duration: U256::from(22),
1453 },
1454 borrowable_token0: TokenLimit {
1455 available: limit_wide,
1456 expands_to: limit_wide,
1457 expand_duration: U256::ZERO,
1458 },
1459 borrowable_token1: TokenLimit {
1460 available: limit_wide,
1461 expands_to: limit_wide,
1462 expand_duration: U256::from(22),
1463 },
1464 }
1465 }
1466
1467 fn limits_tight() -> DexLimits {
1468 let limit_expand_tight = U256::from_str("711907234052361388866").unwrap();
1469
1470 DexLimits {
1471 withdrawable_token0: TokenLimit {
1472 available: U256::from_str("456740438880263").unwrap(),
1473 expands_to: limit_expand_tight,
1474 expand_duration: U256::from(600),
1475 },
1476 withdrawable_token1: TokenLimit {
1477 available: U256::from_str("825179383432029").unwrap(),
1478 expands_to: limit_expand_tight,
1479 expand_duration: U256::from(600),
1480 },
1481 borrowable_token0: TokenLimit {
1482 available: U256::from_str("941825058374170").unwrap(),
1483 expands_to: limit_expand_tight,
1484 expand_duration: U256::from(600),
1485 },
1486 borrowable_token1: TokenLimit {
1487 available: U256::from_str("941825058374170").unwrap(),
1488 expands_to: limit_expand_tight,
1489 expand_duration: U256::from(600),
1490 },
1491 }
1492 }
1493 fn new_col_reserves_one() -> CollateralReserves {
1494 CollateralReserves {
1495 token0_real_reserves: U256::from_str("20000000006000000").unwrap(),
1496 token1_real_reserves: U256::from_str("20000000000500000").unwrap(),
1497 token0_imaginary_reserves: U256::from_str("389736659726997981").unwrap(),
1498 token1_imaginary_reserves: U256::from_str("389736659619871949").unwrap(),
1499 }
1500 }
1501
1502 fn new_col_reserves_empty() -> CollateralReserves {
1503 CollateralReserves {
1504 token0_real_reserves: U256::ZERO,
1505 token1_real_reserves: U256::ZERO,
1506 token0_imaginary_reserves: U256::ZERO,
1507 token1_imaginary_reserves: U256::ZERO,
1508 }
1509 }
1510
1511 fn new_debt_reserves_empty() -> DebtReserves {
1512 DebtReserves {
1513 token0_real_reserves: U256::ZERO,
1514 token1_real_reserves: U256::ZERO,
1515 token0_imaginary_reserves: U256::ZERO,
1516 token1_imaginary_reserves: U256::ZERO,
1517 }
1518 }
1519
1520 fn new_debt_reserves_one() -> DebtReserves {
1521 DebtReserves {
1522 token0_real_reserves: U256::from_str("9486832995556050").unwrap(),
1523 token1_real_reserves: U256::from_str("9486832993079885").unwrap(),
1524 token0_imaginary_reserves: U256::from_str("184868330099560759").unwrap(),
1525 token1_imaginary_reserves: U256::from_str("184868330048879109").unwrap(),
1526 }
1527 }
1528
1529 pub fn get_approx_center_price_in(
1530 amount_to_swap: U256,
1531 swap0_to_1: bool,
1532 col_reserves: &CollateralReserves,
1533 debt_reserves: &DebtReserves,
1534 ) -> Result<U256, anyhow::Error> {
1535 let col_pool_enabled = !col_reserves
1536 .token0_real_reserves
1537 .is_zero() &&
1538 !col_reserves
1539 .token1_real_reserves
1540 .is_zero() &&
1541 !col_reserves
1542 .token0_imaginary_reserves
1543 .is_zero() &&
1544 !col_reserves
1545 .token1_imaginary_reserves
1546 .is_zero();
1547
1548 let debt_pool_enabled = !debt_reserves
1549 .token0_real_reserves
1550 .is_zero() &&
1551 !debt_reserves
1552 .token1_real_reserves
1553 .is_zero() &&
1554 !debt_reserves
1555 .token0_imaginary_reserves
1556 .is_zero() &&
1557 !debt_reserves
1558 .token1_imaginary_reserves
1559 .is_zero();
1560
1561 let (col_i_reserve_in, col_i_reserve_out, debt_i_reserve_in, debt_i_reserve_out) =
1562 if swap0_to_1 {
1563 (
1564 col_reserves.token0_imaginary_reserves,
1565 col_reserves.token1_imaginary_reserves,
1566 debt_reserves.token0_imaginary_reserves,
1567 debt_reserves.token1_imaginary_reserves,
1568 )
1569 } else {
1570 (
1571 col_reserves.token1_imaginary_reserves,
1572 col_reserves.token0_imaginary_reserves,
1573 debt_reserves.token1_imaginary_reserves,
1574 debt_reserves.token0_imaginary_reserves,
1575 )
1576 };
1577
1578 let a = if col_pool_enabled && debt_pool_enabled {
1579 swap_routing_in(
1580 amount_to_swap,
1581 col_i_reserve_out,
1582 col_i_reserve_in,
1583 debt_i_reserve_out,
1584 debt_i_reserve_in,
1585 )
1586 } else if debt_pool_enabled {
1587 U256::MAX } else if col_pool_enabled {
1589 amount_to_swap
1590 .checked_add(U256::from(1))
1591 .unwrap()
1592 } else {
1593 bail!("No pools are enabled");
1594 };
1595
1596 let (amount_in_collateral, amount_in_debt) = if a == U256::MAX || a == U256::ZERO {
1597 (U256::ZERO, amount_to_swap)
1598 } else if a >= amount_to_swap {
1599 (amount_to_swap, U256::ZERO)
1600 } else {
1601 (a, amount_to_swap - a)
1602 };
1603
1604 let price = if amount_in_collateral > amount_in_debt {
1605 if swap0_to_1 {
1606 col_i_reserve_out
1607 .checked_mul(constant::B_I1E27)
1608 .unwrap() /
1609 col_i_reserve_in
1610 } else {
1611 col_i_reserve_in
1612 .checked_mul(constant::B_I1E27)
1613 .unwrap() /
1614 col_i_reserve_out
1615 }
1616 } else if swap0_to_1 {
1617 debt_i_reserve_out
1618 .checked_mul(constant::B_I1E27)
1619 .unwrap() /
1620 debt_i_reserve_in
1621 } else {
1622 debt_i_reserve_in
1623 .checked_mul(constant::B_I1E27)
1624 .unwrap() /
1625 debt_i_reserve_out
1626 };
1627
1628 Ok(price)
1629 }
1630
1631 pub fn get_approx_center_price_out(
1632 amount_out: U256,
1633 swap0_to_1: bool,
1634 col_reserves: &CollateralReserves,
1635 debt_reserves: &DebtReserves,
1636 ) -> Result<U256, SwapError> {
1637 let col_pool_enabled = col_reserves.token0_real_reserves > U256::ZERO &&
1638 col_reserves.token1_real_reserves > U256::ZERO &&
1639 col_reserves.token0_imaginary_reserves > U256::ZERO &&
1640 col_reserves.token1_imaginary_reserves > U256::ZERO;
1641
1642 let debt_pool_enabled = debt_reserves.token0_real_reserves > U256::ZERO &&
1643 debt_reserves.token1_real_reserves > U256::ZERO &&
1644 debt_reserves.token0_imaginary_reserves > U256::ZERO &&
1645 debt_reserves.token1_imaginary_reserves > U256::ZERO;
1646
1647 let (col_i_reserve_in, col_i_reserve_out, debt_i_reserve_in, debt_i_reserve_out) =
1648 if swap0_to_1 {
1649 (
1650 col_reserves.token0_imaginary_reserves,
1651 col_reserves.token1_imaginary_reserves,
1652 debt_reserves.token0_imaginary_reserves,
1653 debt_reserves.token1_imaginary_reserves,
1654 )
1655 } else {
1656 (
1657 col_reserves.token1_imaginary_reserves,
1658 col_reserves.token0_imaginary_reserves,
1659 debt_reserves.token1_imaginary_reserves,
1660 debt_reserves.token0_imaginary_reserves,
1661 )
1662 };
1663
1664 let a = if col_pool_enabled && debt_pool_enabled {
1665 swap_routing_out(
1666 amount_out,
1667 col_i_reserve_in,
1668 col_i_reserve_out,
1669 debt_i_reserve_in,
1670 debt_i_reserve_out,
1671 )
1672 } else if debt_pool_enabled {
1673 U256::MAX } else if col_pool_enabled {
1675 amount_out + U256::ONE } else {
1677 return Err(SwapError::NoPoolsEnabled);
1678 };
1679
1680 let mut amount_in_collateral = U256::ZERO;
1681 let mut amount_in_debt = U256::ZERO;
1682
1683 if a <= U256::ZERO {
1684 amount_in_debt = get_amount_in(amount_out, debt_i_reserve_in, debt_i_reserve_out);
1685 } else if a >= amount_out {
1686 amount_in_collateral = get_amount_in(amount_out, col_i_reserve_in, col_i_reserve_out);
1687 } else {
1688 amount_in_collateral = get_amount_in(a, col_i_reserve_in, col_i_reserve_out);
1689 amount_in_debt = get_amount_in(amount_out - a, debt_i_reserve_in, debt_i_reserve_out);
1690 }
1691
1692 let price = if amount_in_collateral > amount_in_debt {
1693 if swap0_to_1 {
1694 col_i_reserve_out * constant::B_I1E27 / col_i_reserve_in
1695 } else {
1696 col_i_reserve_in * constant::B_I1E27 / col_i_reserve_out
1697 }
1698 } else if swap0_to_1 {
1699 debt_i_reserve_out * constant::B_I1E27 / debt_i_reserve_in
1700 } else {
1701 debt_i_reserve_in * constant::B_I1E27 / debt_i_reserve_out
1702 };
1703
1704 Ok(price)
1705 }
1706
1707 #[test]
1708 fn test_delta_transition_from_attribute() {
1709 let (_, _, mut pool) = setup_fluid_pool(U256::ONE);
1710 let sync_time: u64 = 1_700_000_000;
1711 let delta = ProtocolStateDelta {
1712 updated_attributes: HashMap::from(vm::pending_state_attributes(
1713 alloy::sol_types::SolValue::abi_encode(&vm::sample_pool_with_reserves()),
1714 sync_time,
1715 )),
1716 ..Default::default()
1717 };
1718
1719 pool.delta_transition(delta, &HashMap::new(), &Balances::default())
1720 .expect("delta transition from attribute failed");
1721
1722 assert_eq!(
1725 pool.collateral_reserves
1726 .token0_real_reserves,
1727 U256::from(1u64)
1728 );
1729 assert_eq!(
1730 pool.collateral_reserves
1731 .token1_imaginary_reserves,
1732 U256::from(4u64)
1733 );
1734 assert_eq!(pool.debt_reserves.token0_real_reserves, U256::from(13u64));
1735 assert_eq!(
1736 pool.debt_reserves
1737 .token1_imaginary_reserves,
1738 U256::from(16u64)
1739 );
1740 assert_eq!(
1741 pool.dex_limits
1742 .withdrawable_token0
1743 .available,
1744 U256::from(21u64)
1745 );
1746 assert_eq!(
1747 pool.dex_limits
1748 .borrowable_token1
1749 .expand_duration,
1750 U256::from(32u64)
1751 );
1752 assert_eq!(pool.fee, U256::from(41u64));
1753 assert_eq!(pool.center_price, U256::from(42u64));
1754 assert_eq!(pool.sync_time, sync_time);
1755 assert_eq!(pool.pool_reserve0, U256::from(22u64 + 28u64));
1758 assert_eq!(pool.pool_reserve1, U256::from(25u64 + 31u64));
1759 }
1760
1761 #[test]
1762 fn test_delta_transition_attribute_without_timestamp() {
1763 let (_, _, mut pool) = setup_fluid_pool(U256::ONE);
1764 let delta = ProtocolStateDelta {
1765 updated_attributes: HashMap::from([(
1766 vm::POOL_RESERVES_ADJUSTED_ATTRIBUTE.to_string(),
1767 Bytes::from(alloy::sol_types::SolValue::abi_encode(
1768 &vm::sample_pool_with_reserves(),
1769 )),
1770 )]),
1771 ..Default::default()
1772 };
1773
1774 let result = pool.delta_transition(delta, &HashMap::new(), &Balances::default());
1775
1776 match result {
1777 Err(TransitionError::MissingAttribute(attr)) => {
1778 assert_eq!(attr, vm::BLOCK_TIMESTAMP_ATTRIBUTE)
1779 }
1780 other => panic!("expected MissingAttribute error, got {other:?}"),
1781 }
1782 }
1783
1784 #[test]
1785 fn test_delta_transition_rejects_malformed_timestamp() {
1786 for timestamp in [vec![0; 7], vec![0; 9], vec![0; 32]] {
1787 let delta = ProtocolStateDelta {
1788 updated_attributes: HashMap::from([
1789 (
1790 vm::POOL_RESERVES_ADJUSTED_ATTRIBUTE.to_string(),
1791 Bytes::from(alloy::sol_types::SolValue::abi_encode(
1792 &vm::sample_pool_with_reserves(),
1793 )),
1794 ),
1795 (vm::BLOCK_TIMESTAMP_ATTRIBUTE.to_string(), Bytes::from(timestamp.clone())),
1796 ]),
1797 ..Default::default()
1798 };
1799 let (_, _, mut pool) = setup_fluid_pool(U256::ONE);
1800
1801 let result = pool.delta_transition(delta, &HashMap::new(), &Balances::default());
1802
1803 match result {
1804 Err(TransitionError::DecodeError(message)) => {
1805 assert!(message.contains(&format!("got {} bytes", timestamp.len())));
1806 }
1807 other => panic!("expected DecodeError, got {other:?}"),
1808 }
1809 }
1810 }
1811
1812 #[test]
1813 fn test_calc_amount_out_zero2one() {
1814 let (wsteth, eth, pool) = setup_fluid_pool(U256::ONE);
1815 let cases = [
1816 ("1000000000000000000", "1179917402128000000"),
1817 ("500000000000000000", "589961060629000000"),
1818 ];
1819 for (amount_in_str, exp_out_str) in cases.into_iter() {
1820 let exp_out = BigUint::from_str_radix(exp_out_str, 10).unwrap();
1821 let res = pool
1822 .get_amount_out(BigUint::from_str_radix(amount_in_str, 10).unwrap(), &wsteth, ð)
1823 .unwrap();
1824
1825 assert_eq!(res.amount, exp_out);
1826 }
1827 }
1828
1829 #[test]
1830 fn test_calc_amount_out_one2zero() {
1831 let center_price = U256::from_str("1200000000000000000000000000").unwrap();
1832 let (wsteth, eth, pool) = setup_fluid_pool(center_price);
1833 let cases = [("800000000000000000", "677868867152000000")];
1834 for (amount_in_str, exp_out_str) in cases.into_iter() {
1835 let exp_out = BigUint::from_str_radix(exp_out_str, 10).unwrap();
1836 let res = pool
1837 .get_amount_out(BigUint::from_str_radix(amount_in_str, 10).unwrap(), ð, &wsteth)
1838 .unwrap();
1839
1840 assert_eq!(res.amount, exp_out);
1841 }
1842 }
1843
1844 fn setup_pool_with_decimals(center_price: U256, decimals: u32) -> (Token, Token, FluidV1) {
1845 let (mut token0, mut token1, pool) = setup_fluid_pool(center_price);
1846 token0.decimals = decimals;
1847 token1.decimals = decimals;
1848 let pool = FluidV1::new(
1849 &pool.pool_address,
1850 &token0,
1851 &token1,
1852 pool.collateral_reserves.clone(),
1853 pool.debt_reserves.clone(),
1854 limits_wide(),
1855 pool.center_price,
1856 pool.fee,
1857 pool.sync_time,
1858 );
1859 (token0, token1, pool)
1860 }
1861
1862 #[rstest]
1865 #[case::zero2one(true, U256::ONE, 18, 0.9998)]
1866 #[case::one2zero(false, U256::from(12u64) * U256::from(10u64).pow(U256::from(26u64)), 18, 0.99995)]
1867 #[case::six_decimals(true, U256::ONE, 6, 0.9998)]
1868 fn test_swap_to_price_lands_in_band(
1869 #[case] zero2one: bool,
1870 #[case] center_price: U256,
1871 #[case] decimals: u32,
1872 #[case] multiplier: f64,
1873 ) {
1874 let (token0, token1, pool) = setup_pool_with_decimals(center_price, decimals);
1875 let (token_in, token_out) = if zero2one { (token0, token1) } else { (token1, token0) };
1876 let target = pool
1877 .spot_price(&token_in, &token_out)
1878 .unwrap() *
1879 multiplier;
1880 let params = target_price_params(
1881 &token_in,
1882 &token_out,
1883 to_price(target, &token_in, &token_out),
1884 1e-5,
1885 );
1886
1887 let swap = pool.query_pool_swap(¶ms).unwrap();
1888
1889 assert!(swap.price_points().is_none(), "expected the closed form");
1890 let new_spot = swap
1891 .new_state()
1892 .spot_price(&token_in, &token_out)
1893 .unwrap();
1894 assert!(
1895 new_spot >= target * (1.0 - 1e-12) && new_spot <= target * (1.0 + 1e-5),
1896 "{new_spot}"
1897 );
1898 }
1899
1900 #[test]
1901 fn test_swap_to_price_target_above_spot() {
1902 let (wsteth, eth, pool) = setup_fluid_pool(U256::ONE);
1903 let spot = pool.spot_price(&wsteth, ð).unwrap();
1904 let params =
1905 target_price_params(&wsteth, ð, to_price(spot * 1.01, &wsteth, ð), 0.001);
1906
1907 let result = pool.query_pool_swap(¶ms);
1908
1909 assert!(matches!(result, Err(SimulationError::InvalidInput(..))), "{result:?}");
1910 }
1911
1912 #[test]
1913 fn test_swap_to_price_target_equal_to_spot() {
1914 let (wsteth, eth, pool) = setup_fluid_pool(U256::ONE);
1915 let spot = pool.spot_price(&wsteth, ð).unwrap();
1916 let scale = 1u128 << 52;
1918 #[expect(
1919 clippy::cast_possible_truncation,
1920 clippy::cast_sign_loss,
1921 reason = "the scaled spot is a positive exact integer below 2^53"
1922 )]
1923 let target_numerator = (spot * scale as f64) as u128;
1924 let target = Price::new(BigUint::from(target_numerator), BigUint::from(scale));
1925 let params = target_price_params(&wsteth, ð, target, 0.001);
1926
1927 let swap = pool.query_pool_swap(¶ms).unwrap();
1928
1929 assert_eq!(swap.amount_in(), &BigUint::ZERO);
1930 assert!(swap.new_state().eq(&pool));
1931 }
1932
1933 #[test]
1934 fn test_swap_to_price_outside_band_uses_numerical_search() {
1935 let (token0, token1, pool) = setup_pool_with_decimals(U256::ONE, 6);
1938 let spot = pool
1939 .spot_price(&token0, &token1)
1940 .unwrap();
1941 let params =
1942 target_price_params(&token0, &token1, to_price(spot * 0.9998, &token0, &token1), 0.0);
1943
1944 let swap = pool.query_pool_swap(¶ms).unwrap();
1945
1946 assert!(swap.price_points().is_some(), "expected the numerical search");
1947 }
1948
1949 #[test]
1950 fn test_amount_out_exceeds_reserve() {
1951 let (wsteth, eth, mut pool) = setup_fluid_pool(U256::ONE);
1952 pool.pool_reserve0 = U256::from_str("18760613183894").unwrap();
1954 pool.pool_reserve1 = U256::from_str("22123580158026").unwrap();
1955 let amount_in = BigUint::from_str_radix("30000000000000000000", 10).unwrap(); let result = pool.get_amount_out(amount_in, &wsteth, ð);
1957
1958 assert!(result.is_err(), "Expected an error for exceeding reserves");
1959 assert_eq!(
1960 result.unwrap_err().to_string(),
1961 SimulationError::from(SwapError::InsufficientReserve).to_string()
1962 );
1963 }
1964
1965 #[test]
1966 fn test_swap_in() {
1967 let sync_time = SystemTime::now()
1968 .duration_since(UNIX_EPOCH)
1969 .unwrap()
1970 .as_secs();
1971
1972 assert_swap_in_result(
1973 true,
1974 U256::from(1_000_000_000_000_000u128), new_col_reserves_one(),
1976 new_debt_reserves_one(),
1977 "998262697204710000000",
1978 12,
1979 18,
1980 limits_wide(),
1981 sync_time - 10,
1982 );
1983
1984 assert_swap_in_result(
1985 true,
1986 U256::from(1_000_000_000_000_000u128),
1987 new_col_reserves_empty(),
1988 new_debt_reserves_one(),
1989 "994619847016724000000",
1990 12,
1991 18,
1992 limits_wide(),
1993 sync_time - 10,
1994 );
1995
1996 assert_swap_in_result(
1997 true,
1998 U256::from(1_000_000_000_000_000u128),
1999 new_col_reserves_one(),
2000 new_debt_reserves_empty(),
2001 "997440731289905000000",
2002 12,
2003 18,
2004 limits_wide(),
2005 sync_time - 10,
2006 );
2007
2008 assert_swap_in_result(
2009 false,
2010 U256::from(1_000_000_000_000_000u128),
2011 new_col_reserves_one(),
2012 new_debt_reserves_one(),
2013 "998262697752553000000",
2014 12,
2015 18,
2016 limits_wide(),
2017 sync_time - 10,
2018 );
2019
2020 assert_swap_in_result(
2021 false,
2022 U256::from(1_000_000_000_000_000u128),
2023 new_col_reserves_empty(),
2024 new_debt_reserves_one(),
2025 "994619847560607000000",
2026 12,
2027 18,
2028 limits_wide(),
2029 sync_time - 10,
2030 );
2031
2032 assert_swap_in_result(
2033 false,
2034 U256::from(1_000_000_000_000_000u128),
2035 new_col_reserves_one(),
2036 new_debt_reserves_empty(),
2037 "997440731837532000000",
2038 12,
2039 18,
2040 limits_wide(),
2041 sync_time - 10,
2042 );
2043 }
2044
2045 #[expect(
2058 clippy::too_many_arguments,
2059 reason = "test helper takes every input and expected output of a swap case"
2060 )]
2061 fn assert_swap_in_result(
2062 swap0_to_1: bool,
2063 amount_in: U256,
2064 mut col_reserves: CollateralReserves,
2065 mut debt_reserves: DebtReserves,
2066 expected_amount_out: &str,
2067 in_decimals: i64,
2068 out_decimals: i64,
2069 mut limits: DexLimits,
2070 sync_time: u64,
2071 ) {
2072 let price =
2073 get_approx_center_price_in(amount_in, swap0_to_1, &col_reserves, &debt_reserves)
2074 .expect("Failed to get approx center price");
2075
2076 let adjusted_amount_in = to_adjusted_amount(amount_in, in_decimals);
2077 let out_amt = swap_in_adjusted(
2078 swap0_to_1,
2079 adjusted_amount_in,
2080 &mut col_reserves,
2081 &mut debt_reserves,
2082 out_decimals,
2083 &mut limits,
2084 price,
2085 sync_time,
2086 )
2087 .expect("Failed to calculate swap in adjusted");
2088
2089 assert_eq!(expected_amount_out, out_amt.to_string(), "Amount out mismatch");
2090 }
2091
2092 #[expect(
2093 clippy::too_many_arguments,
2094 reason = "test helper takes every input and expected output of a swap case"
2095 )]
2096 fn assert_swap_out_result(
2097 swap0_to_1: bool,
2098 amount_out: U256,
2099 mut col_reserves: CollateralReserves,
2100 mut debt_reserves: DebtReserves,
2101 expected_amount_in: &str,
2102 in_decimals: i64,
2103 out_decimals: i64,
2104 mut limits: DexLimits,
2105 sync_time: i64,
2106 ) {
2107 let price =
2108 get_approx_center_price_out(amount_out, swap0_to_1, &col_reserves, &debt_reserves)
2109 .expect("failed to get approx center price");
2110
2111 let in_amt = swap_out_adjusted(
2112 swap0_to_1,
2113 to_adjusted_amount(amount_out, out_decimals),
2114 &mut col_reserves,
2115 &mut debt_reserves,
2116 in_decimals,
2117 out_decimals,
2118 &mut limits,
2119 price,
2120 u64::try_from(sync_time).unwrap(),
2121 )
2122 .expect("swap_out_adjusted failed");
2123
2124 assert_eq!(expected_amount_in, from_adjusted_amount(in_amt, in_decimals).to_string());
2125 }
2126
2127 #[test]
2128 fn test_swap_in_limits() {
2129 let sync_time = SystemTime::now()
2130 .duration_since(UNIX_EPOCH)
2131 .unwrap()
2132 .as_secs();
2133
2134 let price = get_approx_center_price_in(
2136 U256::from(1_000_000_000_000_000u128),
2137 true,
2138 &new_col_reserves_one(),
2139 &new_debt_reserves_one(),
2140 )
2141 .unwrap();
2142
2143 let res = swap_in_adjusted(
2144 true,
2145 U256::from(1_000_000_000_000_000u128),
2146 &mut new_col_reserves_one(),
2147 &mut new_debt_reserves_one(),
2148 18,
2149 &mut limits_tight(),
2150 price,
2151 sync_time - 10,
2152 );
2153
2154 assert_eq!(res.unwrap_err().to_string(), SwapError::InsufficientBorrowable.to_string());
2155
2156 let price = get_approx_center_price_out(
2158 U256::from(1_000_000_000_000_000u128),
2159 true,
2160 &new_col_reserves_one(),
2161 &new_debt_reserves_one(),
2162 )
2163 .unwrap();
2164
2165 let out_amt = swap_in_adjusted(
2166 true,
2167 U256::from(1_000_000_000_000_000u128),
2168 &mut new_col_reserves_one(),
2169 &mut new_debt_reserves_one(),
2170 18,
2171 &mut limits_tight(),
2172 price,
2173 sync_time - 6000,
2174 )
2175 .unwrap();
2176
2177 assert_eq!(out_amt.to_string(), "998262697204710000000");
2178
2179 let price = get_approx_center_price_out(
2181 U256::from(30_000_000_000_000_000u128),
2182 true,
2183 &new_col_reserves_one(),
2184 &new_debt_reserves_one(),
2185 )
2186 .unwrap();
2187
2188 let res = swap_in_adjusted(
2189 true,
2190 U256::from(30_000_000_000_000_000u128),
2191 &mut new_col_reserves_one(),
2192 &mut new_debt_reserves_one(),
2193 18,
2194 &mut limits_wide(),
2195 price,
2196 sync_time - 10,
2197 );
2198
2199 assert_eq!(res.unwrap_err().to_string(), SwapError::InsufficientMaxPrice.to_string());
2200
2201 let price = get_approx_center_price_out(
2203 U256::from(50_000_000_000_000_000u128),
2204 true,
2205 &new_col_reserves_one(),
2206 &new_debt_reserves_one(),
2207 )
2208 .unwrap();
2209
2210 let res = swap_in_adjusted(
2211 true,
2212 U256::from(50_000_000_000_000_000u128),
2213 &mut new_col_reserves_one(),
2214 &mut new_debt_reserves_one(),
2215 18,
2216 &mut limits_wide(),
2217 price,
2218 sync_time - 10,
2219 );
2220
2221 assert_eq!(res.unwrap_err().to_string(), SwapError::InsufficientReserve.to_string());
2222 }
2223
2224 #[test]
2225 fn test_swap_in_adjusted_compare_estimate_in() {
2226 let now = SystemTime::now()
2227 .duration_since(UNIX_EPOCH)
2228 .unwrap()
2229 .as_secs();
2230 let expected_amount_out = U256::from_str("1180035404724000000").unwrap();
2231 let mut col_reserves = CollateralReserves {
2232 token0_real_reserves: U256::from_str("2169934539358").unwrap(),
2233 token1_real_reserves: U256::from_str("19563846299171").unwrap(),
2234 token0_imaginary_reserves: U256::from_str("62490032619260838").unwrap(),
2235 token1_imaginary_reserves: U256::from_str("73741038977020279").unwrap(),
2236 };
2237 let mut debt_reserves = DebtReserves {
2238 token0_real_reserves: U256::from_str("2169108220421").unwrap(),
2239 token1_real_reserves: U256::from_str("19572550738602").unwrap(),
2240 token0_imaginary_reserves: U256::from_str("62511862774117387").unwrap(),
2241 token1_imaginary_reserves: U256::from_str("73766803277429176").unwrap(),
2242 };
2243 let amount_in = U256::from(1000000000000u128); let price = get_approx_center_price_in(amount_in, true, &col_reserves, &debt_reserves)
2245 .expect("Failed to get approximate center price");
2246
2247 let out_amt = swap_in_adjusted(
2248 true,
2249 amount_in,
2250 &mut col_reserves,
2251 &mut debt_reserves,
2252 18,
2253 &mut limits_wide(),
2254 price,
2255 now - 10,
2256 )
2257 .expect("Failed to swap in adjusted");
2258
2259 assert_eq!(expected_amount_out, out_amt);
2260 }
2261
2262 #[test]
2263 fn test_swap_in_debt_empty() {
2264 let now = SystemTime::now()
2265 .duration_since(UNIX_EPOCH)
2266 .unwrap()
2267 .as_secs();
2268
2269 assert_swap_in_result(
2270 true,
2271 U256::from_str("1000000000000000").unwrap(),
2272 new_col_reserves_empty(),
2273 new_debt_reserves_one(),
2274 "994619847016724",
2275 12,
2276 12,
2277 limits_wide(),
2278 now - 10,
2279 );
2280
2281 assert_swap_in_result(
2282 false,
2283 U256::from_str("1000000000000000").unwrap(),
2284 new_col_reserves_empty(),
2285 new_debt_reserves_one(),
2286 "994619847560607",
2287 12,
2288 12,
2289 limits_wide(),
2290 now - 10,
2291 )
2292 }
2293
2294 #[test]
2295 fn test_swap_in_col_empty() {
2296 let now = SystemTime::now()
2297 .duration_since(UNIX_EPOCH)
2298 .unwrap()
2299 .as_secs();
2300
2301 assert_swap_in_result(
2302 true,
2303 U256::from_str("1000000000000000").unwrap(),
2304 new_col_reserves_one(),
2305 new_debt_reserves_empty(),
2306 "997440731289905",
2307 12,
2308 12,
2309 limits_wide(),
2310 now - 10,
2311 );
2312
2313 assert_swap_in_result(
2314 false,
2315 U256::from_str("1000000000000000").unwrap(),
2316 new_col_reserves_one(),
2317 new_debt_reserves_empty(),
2318 "997440731837532",
2319 12,
2320 12,
2321 limits_wide(),
2322 now - 10,
2323 )
2324 }
2325
2326 #[test]
2327 fn test_swap_out() {
2328 let sync_time = (i64::try_from(
2329 SystemTime::now()
2330 .duration_since(UNIX_EPOCH)
2331 .unwrap()
2332 .as_secs(),
2333 )
2334 .unwrap()) -
2335 10;
2336
2337 assert_swap_out_result(
2338 true,
2339 U256::from(1_000_000_000_000_000u64),
2340 new_col_reserves_one(),
2341 new_debt_reserves_one(),
2342 "1001743360284199",
2343 12,
2344 12,
2345 limits_wide(),
2346 sync_time,
2347 );
2348
2349 assert_swap_out_result(
2350 true,
2351 U256::from(1_000_000_000_000_000u64),
2352 new_col_reserves_empty(),
2353 new_debt_reserves_one(),
2354 "1005438674786548",
2355 12,
2356 12,
2357 limits_wide(),
2358 sync_time,
2359 );
2360
2361 assert_swap_out_result(
2362 true,
2363 U256::from(1_000_000_000_000_000u64),
2364 new_col_reserves_one(),
2365 new_debt_reserves_empty(),
2366 "1002572435818386",
2367 12,
2368 12,
2369 limits_wide(),
2370 sync_time,
2371 );
2372
2373 assert_swap_out_result(
2374 false,
2375 U256::from(1_000_000_000_000_000u64),
2376 new_col_reserves_one(),
2377 new_debt_reserves_one(),
2378 "1001743359733488",
2379 12,
2380 12,
2381 limits_wide(),
2382 sync_time,
2383 );
2384
2385 assert_swap_out_result(
2386 false,
2387 U256::from(1_000_000_000_000_000u64),
2388 new_col_reserves_empty(),
2389 new_debt_reserves_one(),
2390 "1005438674233767",
2391 12,
2392 12,
2393 limits_wide(),
2394 sync_time,
2395 );
2396
2397 assert_swap_out_result(
2398 false,
2399 U256::from(1_000_000_000_000_000u64),
2400 new_col_reserves_one(),
2401 new_debt_reserves_empty(),
2402 "1002572435266527",
2403 12,
2404 12,
2405 limits_wide(),
2406 sync_time,
2407 );
2408 }
2409
2410 #[test]
2411 fn test_swap_out_limits() {
2412 let sync_time_recent = (SystemTime::now()
2413 .duration_since(UNIX_EPOCH)
2414 .unwrap()
2415 .as_secs()) -
2416 10;
2417
2418 let sync_time_expanded = sync_time_recent - 5990; let price = get_approx_center_price_out(
2422 U256::from(1_000_000_000_000_000u64),
2423 true,
2424 &new_col_reserves_one(),
2425 &new_debt_reserves_one(),
2426 )
2427 .unwrap();
2428
2429 let result = swap_out_adjusted(
2430 true,
2431 U256::from(1_000_000_000_000_000u64),
2432 &mut new_col_reserves_one(),
2433 &mut new_debt_reserves_one(),
2434 12,
2435 18,
2436 &mut limits_tight(),
2437 price,
2438 sync_time_recent,
2439 );
2440
2441 assert!(matches!(result, Err(SwapError::InsufficientBorrowable)));
2442
2443 let price = get_approx_center_price_out(
2445 U256::from(1_000_000_000_000_000u64),
2446 true,
2447 &new_col_reserves_one(),
2448 &new_debt_reserves_one(),
2449 )
2450 .unwrap();
2451
2452 let result = swap_out_adjusted(
2453 true,
2454 U256::from(1_000_000_000_000_000u64),
2455 &mut new_col_reserves_one(),
2456 &mut new_debt_reserves_one(),
2457 12,
2458 18,
2459 &mut limits_tight(),
2460 price,
2461 sync_time_expanded,
2462 )
2463 .unwrap();
2464
2465 assert_eq!(from_adjusted_amount(result, 12).to_string(), "1001743360284199");
2466
2467 let price = get_approx_center_price_out(
2469 U256::from(20_000_000_000_000_000u64),
2470 true,
2471 &new_col_reserves_one(),
2472 &new_debt_reserves_one(),
2473 )
2474 .unwrap();
2475
2476 let result = swap_out_adjusted(
2477 true,
2478 U256::from(20_000_000_000_000_000u64),
2479 &mut new_col_reserves_one(),
2480 &mut new_debt_reserves_one(),
2481 12,
2482 18,
2483 &mut limits_wide(),
2484 price,
2485 sync_time_recent,
2486 );
2487
2488 assert!(matches!(result, Err(SwapError::InsufficientMaxPrice)));
2489
2490 let price = get_approx_center_price_out(
2492 U256::from(30_000_000_000_000_000u64),
2493 true,
2494 &new_col_reserves_one(),
2495 &new_debt_reserves_one(),
2496 )
2497 .unwrap();
2498
2499 let result = swap_out_adjusted(
2500 true,
2501 U256::from(30_000_000_000_000_000u64),
2502 &mut new_col_reserves_one(),
2503 &mut new_debt_reserves_one(),
2504 12,
2505 18,
2506 &mut limits_wide(),
2507 price,
2508 sync_time_recent,
2509 );
2510
2511 assert!(matches!(result, Err(SwapError::InsufficientReserve)));
2512 }
2513
2514 #[test]
2515 fn test_swap_out_empty_debt() {
2516 let sync_time = (i64::try_from(
2517 SystemTime::now()
2518 .duration_since(UNIX_EPOCH)
2519 .unwrap()
2520 .as_secs(),
2521 )
2522 .unwrap()) -
2523 10;
2524
2525 assert_swap_out_result(
2527 true,
2528 U256::from(994_619_847_016_724u64),
2529 new_col_reserves_empty(),
2530 new_debt_reserves_one(),
2531 "999999999999999",
2532 12,
2533 12,
2534 limits_wide(),
2535 sync_time,
2536 );
2537
2538 assert_swap_out_result(
2540 false,
2541 U256::from(994_619_847_560_607u64),
2542 new_col_reserves_empty(),
2543 new_debt_reserves_one(),
2544 "999999999999999",
2545 12,
2546 12,
2547 limits_wide(),
2548 sync_time,
2549 );
2550 }
2551
2552 #[test]
2553 fn test_swap_out_empty_collateral() {
2554 let sync_time = (i64::try_from(
2555 SystemTime::now()
2556 .duration_since(UNIX_EPOCH)
2557 .unwrap()
2558 .as_secs(),
2559 )
2560 .unwrap()) -
2561 10;
2562
2563 assert_swap_out_result(
2565 true,
2566 U256::from(997_440_731_289_905u64),
2567 new_col_reserves_one(),
2568 new_debt_reserves_empty(),
2569 "999999999999999",
2570 12,
2571 12,
2572 limits_wide(),
2573 sync_time,
2574 );
2575
2576 assert_swap_out_result(
2578 false,
2579 U256::from(997_440_731_837_532u64),
2580 new_col_reserves_one(),
2581 new_debt_reserves_empty(),
2582 "999999999999999",
2583 12,
2584 12,
2585 limits_wide(),
2586 sync_time,
2587 );
2588 }
2589
2590 pub fn new_verify_ratio_col_reserves() -> CollateralReserves {
2591 CollateralReserves {
2592 token0_real_reserves: U256::from(2_000_000u64) * U256::from(10u64).pow(U256::from(12)),
2593 token1_real_reserves: U256::from(15_000u64) * U256::from(10u64).pow(U256::from(12)),
2594 token0_imaginary_reserves: U256::ZERO,
2595 token1_imaginary_reserves: U256::ZERO,
2596 }
2597 }
2598
2599 pub fn new_verify_ratio_debt_reserves() -> DebtReserves {
2600 DebtReserves {
2601 token0_real_reserves: U256::from(2_000_000u64) * U256::from(10u64).pow(U256::from(12)),
2602 token1_real_reserves: U256::from(15_000u64) * U256::from(10u64).pow(U256::from(12)),
2603 token0_imaginary_reserves: U256::ZERO,
2604 token1_imaginary_reserves: U256::ZERO,
2605 }
2606 }
2607
2608 pub fn calculate_reserves_outside_range(
2610 geometric_mean_price: U256,
2611 price_at_range: U256,
2612 reserve_x: U256,
2613 reserve_y: U256,
2614 ) -> (I256, I256) {
2615 let geometric_mean_price = I256::from(geometric_mean_price);
2616 let price_at_range = I256::from(price_at_range);
2617 let reserve_x = I256::from(reserve_x);
2618 let reserve_y = I256::from(reserve_y);
2619
2620 let one_e27 = I256::from(constant::B_I1E27);
2621 let two = I256::try_from(2i8).unwrap();
2622
2623 let part1 = price_at_range
2625 .checked_sub(geometric_mean_price)
2626 .expect("priceAtRange must be >= geometricMeanPrice");
2627
2628 let part2 = geometric_mean_price
2630 .checked_mul(reserve_x)
2631 .unwrap()
2632 .checked_add(reserve_y.checked_mul(one_e27).unwrap())
2633 .unwrap()
2634 .checked_div(two.checked_mul(part1).unwrap())
2635 .unwrap();
2636
2637 let mut part3 = reserve_x
2639 .checked_mul(reserve_y)
2640 .unwrap();
2641
2642 let one_e50 = I256::try_from(10)
2643 .unwrap()
2644 .pow(U256::from(50));
2645
2646 if part3 < one_e50 {
2648 part3 = part3
2649 .checked_mul(one_e27)
2650 .unwrap()
2651 .checked_div(part1)
2652 .unwrap();
2653 } else {
2654 part3 = part3
2655 .checked_div(part1)
2656 .unwrap()
2657 .checked_mul(one_e27)
2658 .unwrap();
2659 }
2660
2661 let part2_squared = part2.checked_mul(part2).unwrap();
2663 let inside_sqrt = part3
2664 .checked_add(part2_squared)
2665 .unwrap();
2666 let sqrt_value = I256::from(
2667 U256::try_from(inside_sqrt)
2668 .unwrap()
2669 .root(2),
2670 );
2671
2672 let reserve_x_outside = part2.checked_add(sqrt_value).unwrap();
2673
2674 let reserve_y_outside = reserve_x_outside
2676 .checked_mul(geometric_mean_price)
2677 .unwrap()
2678 .checked_div(one_e27)
2679 .unwrap();
2680
2681 (reserve_x_outside, reserve_y_outside)
2682 }
2683
2684 #[test]
2685 fn test_swap_in_verify_reserves_in_range() {
2686 let decimals: i64 = 6;
2687 let mut col_reserves = new_verify_ratio_col_reserves();
2688 let mut debt_reserves = new_verify_ratio_debt_reserves();
2689
2690 let mut price = U256::from_str("1000001000000000000000000000").unwrap();
2691
2692 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2694 constant::B_I1E27,
2695 price,
2696 col_reserves.token0_real_reserves,
2697 col_reserves.token1_real_reserves,
2698 );
2699
2700 col_reserves.token0_imaginary_reserves =
2701 U256::from(reserve_x_outside + I256::from(col_reserves.token0_real_reserves));
2702 col_reserves.token1_imaginary_reserves = U256::from(
2703 I256::from(reserve_y_outside) + I256::from(col_reserves.token1_real_reserves),
2704 );
2705
2706 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2708 constant::B_I1E27,
2709 price,
2710 debt_reserves.token0_real_reserves,
2711 debt_reserves.token1_real_reserves,
2712 );
2713
2714 debt_reserves.token0_imaginary_reserves =
2715 U256::from(reserve_x_outside + I256::from(debt_reserves.token0_real_reserves));
2716 debt_reserves.token1_imaginary_reserves = U256::from(
2717 I256::from(reserve_y_outside) + I256::from(debt_reserves.token1_real_reserves),
2718 );
2719
2720 let sync_time = SystemTime::now()
2721 .duration_since(UNIX_EPOCH)
2722 .unwrap()
2723 .as_secs() -
2724 10;
2725
2726 let swap_amount = U256::from(14_905) * U256::from(10).pow(U256::from(12)); price = get_approx_center_price_in(
2729 swap_amount,
2730 true,
2731 &col_reserves,
2732 &new_debt_reserves_empty(),
2733 )
2734 .unwrap();
2735 let result = swap_in_adjusted(
2736 true,
2737 swap_amount,
2738 &mut col_reserves,
2739 &mut new_debt_reserves_empty(),
2740 decimals,
2741 &mut limits_wide(),
2742 price,
2743 sync_time,
2744 );
2745 assert!(
2746 result.is_err(),
2747 "FAIL: reserves ratio revert NOT hit for col reserves when swap amount 14_905"
2748 );
2749
2750 price = get_approx_center_price_in(
2751 swap_amount,
2752 true,
2753 &new_col_reserves_empty(),
2754 &debt_reserves,
2755 )
2756 .unwrap();
2757 let result = swap_in_adjusted(
2758 true,
2759 swap_amount,
2760 &mut new_col_reserves_empty(),
2761 &mut debt_reserves,
2762 decimals,
2763 &mut limits_wide(),
2764 price,
2765 sync_time,
2766 );
2767 assert!(
2768 result.is_err(),
2769 "FAIL: reserves ratio revert NOT hit for debt reserves when swap amount 14_905"
2770 );
2771
2772 col_reserves = new_verify_ratio_col_reserves();
2774 debt_reserves = new_verify_ratio_debt_reserves();
2775
2776 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2777 constant::B_I1E27,
2778 price,
2779 col_reserves.token0_real_reserves,
2780 col_reserves.token1_real_reserves,
2781 );
2782
2783 col_reserves.token0_imaginary_reserves =
2784 U256::from(reserve_x_outside + I256::from(col_reserves.token0_real_reserves));
2785 col_reserves.token1_imaginary_reserves = U256::from(
2786 I256::from(reserve_y_outside) + I256::from(col_reserves.token1_real_reserves),
2787 );
2788
2789 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2790 constant::B_I1E27,
2791 price,
2796 debt_reserves.token0_real_reserves,
2797 debt_reserves.token1_real_reserves,
2798 );
2799 debt_reserves.token0_imaginary_reserves =
2800 U256::from(reserve_x_outside + I256::from(debt_reserves.token0_real_reserves));
2801 debt_reserves.token1_imaginary_reserves = U256::from(
2802 I256::from(reserve_y_outside) + I256::from(debt_reserves.token1_real_reserves),
2803 );
2804
2805 let swap_amount = U256::from(14_895) * U256::from(10).pow(U256::from(12));
2807
2808 price = get_approx_center_price_in(
2809 swap_amount,
2810 true,
2811 &col_reserves,
2812 &new_debt_reserves_empty(),
2813 )
2814 .unwrap();
2815 let result = swap_in_adjusted(
2816 true,
2817 swap_amount,
2818 &mut col_reserves,
2819 &mut new_debt_reserves_empty(),
2820 decimals,
2821 &mut limits_wide(),
2822 price,
2823 sync_time,
2824 );
2825 assert!(
2826 result.is_ok(),
2827 "FAIL: reserves ratio revert hit for col reserves when swap amount 14_895"
2828 );
2829
2830 price = get_approx_center_price_in(
2831 swap_amount,
2832 true,
2833 &new_col_reserves_empty(),
2834 &debt_reserves,
2835 )
2836 .unwrap();
2837 let result = swap_in_adjusted(
2838 true,
2839 swap_amount,
2840 &mut new_col_reserves_empty(),
2841 &mut debt_reserves,
2842 decimals,
2843 &mut limits_wide(),
2844 price,
2845 sync_time,
2846 );
2847 assert!(
2848 result.is_ok(),
2849 "FAIL: reserves ratio revert hit for debt reserves when swap amount 14_895"
2850 );
2851 }
2852
2853 pub fn new_verify_ratio_col_reserves_swap_out() -> CollateralReserves {
2854 CollateralReserves {
2855 token0_real_reserves: U256::from(15_000u64) * U256::from(10u64).pow(U256::from(12)), token1_real_reserves: U256::from(2_000_000u64) * U256::from(10u64).pow(U256::from(12)), token0_imaginary_reserves: U256::ZERO,
2858 token1_imaginary_reserves: U256::ZERO,
2859 }
2860 }
2861
2862 pub fn new_verify_ratio_debt_reserves_swap_out() -> DebtReserves {
2863 DebtReserves {
2864 token0_real_reserves: U256::from(15_000u64) * U256::from(10u64).pow(U256::from(12)),
2865 token1_real_reserves: U256::from(2_000_000u64) * U256::from(10u64).pow(U256::from(12)),
2866 token0_imaginary_reserves: U256::ZERO,
2867 token1_imaginary_reserves: U256::ZERO,
2868 }
2869 }
2870
2871 #[test]
2872 fn test_swap_out_verify_reserves_in_range() {
2873 let decimals: i64 = 6;
2874 let sync_time = SystemTime::now()
2875 .duration_since(UNIX_EPOCH)
2876 .unwrap()
2877 .as_secs() -
2878 10;
2879
2880 let mut col_reserves = new_verify_ratio_col_reserves_swap_out();
2881 let mut debt_reserves = new_verify_ratio_debt_reserves_swap_out();
2882
2883 let price = U256::from_str("1000001000000000000000000000").unwrap();
2885
2886 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2888 constant::B_I1E27,
2889 price,
2890 col_reserves.token0_real_reserves,
2891 col_reserves.token1_real_reserves,
2892 );
2893 col_reserves.token0_imaginary_reserves =
2894 U256::from(reserve_x_outside + I256::from(col_reserves.token0_real_reserves));
2895 col_reserves.token1_imaginary_reserves =
2896 U256::from(reserve_y_outside + I256::from(col_reserves.token1_real_reserves));
2897
2898 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2899 constant::B_I1E27,
2900 price,
2901 debt_reserves.token0_real_reserves,
2902 debt_reserves.token1_real_reserves,
2903 );
2904 debt_reserves.token0_imaginary_reserves =
2905 U256::from(reserve_x_outside + I256::from(debt_reserves.token0_real_reserves));
2906 debt_reserves.token1_imaginary_reserves =
2907 U256::from(reserve_y_outside + I256::from(debt_reserves.token1_real_reserves));
2908
2909 let swap_amount = U256::from(14_766u64) * U256::from(10u64).pow(U256::from(12));
2911
2912 let price = get_approx_center_price_out(
2913 swap_amount,
2914 false,
2915 &col_reserves,
2916 &new_debt_reserves_empty(),
2917 )
2918 .unwrap();
2919 let result = swap_out_adjusted(
2920 false,
2921 swap_amount,
2922 &mut col_reserves,
2923 &mut new_debt_reserves_empty(),
2924 decimals,
2925 decimals,
2926 &mut limits_wide(),
2927 price,
2928 sync_time,
2929 );
2930 assert!(result.is_err(), "FAIL: reserves ratio verification revert NOT hit for col reserves when swap amount 14_766");
2931
2932 let price = get_approx_center_price_out(
2933 swap_amount,
2934 false,
2935 &new_col_reserves_empty(),
2936 &debt_reserves,
2937 )
2938 .unwrap();
2939 let result = swap_out_adjusted(
2940 false,
2941 swap_amount,
2942 &mut new_col_reserves_empty(),
2943 &mut debt_reserves,
2944 decimals,
2945 decimals,
2946 &mut limits_wide(),
2947 price,
2948 sync_time,
2949 );
2950 assert!(result.is_err(), "FAIL: reserves ratio verification revert NOT hit for debt reserves when swap amount 14_766");
2951
2952 col_reserves = new_verify_ratio_col_reserves_swap_out();
2954 debt_reserves = new_verify_ratio_debt_reserves_swap_out();
2955
2956 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2957 constant::B_I1E27,
2958 price,
2959 col_reserves.token0_real_reserves,
2960 col_reserves.token1_real_reserves,
2961 );
2962 col_reserves.token0_imaginary_reserves =
2963 U256::from(reserve_x_outside + I256::from(col_reserves.token0_real_reserves));
2964 col_reserves.token1_imaginary_reserves =
2965 U256::from(reserve_y_outside + I256::from(col_reserves.token1_real_reserves));
2966
2967 let (reserve_x_outside, reserve_y_outside) = calculate_reserves_outside_range(
2968 constant::B_I1E27,
2969 price,
2970 debt_reserves.token0_real_reserves,
2971 debt_reserves.token1_real_reserves,
2972 );
2973 debt_reserves.token0_imaginary_reserves =
2974 U256::from(reserve_x_outside + I256::from(debt_reserves.token0_real_reserves));
2975 debt_reserves.token1_imaginary_reserves =
2976 U256::from(reserve_y_outside + I256::from(debt_reserves.token1_real_reserves));
2977
2978 let swap_amount = U256::from(14_762u64) * U256::from(10u64).pow(U256::from(12));
2980
2981 let price = get_approx_center_price_out(
2982 swap_amount,
2983 false,
2984 &col_reserves,
2985 &new_debt_reserves_empty(),
2986 )
2987 .unwrap();
2988 let result = swap_out_adjusted(
2989 false,
2990 swap_amount,
2991 &mut col_reserves,
2992 &mut new_debt_reserves_empty(),
2993 decimals,
2994 decimals,
2995 &mut limits_wide(),
2996 price,
2997 sync_time,
2998 );
2999 assert!(
3000 result.is_ok(),
3001 "FAIL: reserves ratio verification revert hit for col reserves when swap amount 14_762"
3002 );
3003
3004 let price = get_approx_center_price_out(
3005 swap_amount,
3006 false,
3007 &new_col_reserves_empty(),
3008 &debt_reserves,
3009 )
3010 .unwrap();
3011 let result = swap_out_adjusted(
3012 false,
3013 swap_amount,
3014 &mut new_col_reserves_empty(),
3015 &mut debt_reserves,
3016 decimals,
3017 decimals,
3018 &mut limits_wide(),
3019 price,
3020 sync_time,
3021 );
3022 assert!(result.is_ok(), "FAIL: reserves ratio verification revert hit for debt reserves when swap amount 14_762");
3023 }
3024
3025 fn hard_limit(l: u128) -> TokenLimit {
3042 TokenLimit {
3043 available: U256::from(l),
3044 expands_to: U256::from(l),
3045 expand_duration: U256::ZERO,
3046 }
3047 }
3048
3049 fn wsteth_eth_pool_23526115() -> (Token, Token, FluidV1) {
3050 let wsteth = Token::new(
3051 &Bytes::from_str("0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0").unwrap(),
3052 "wsteth",
3053 18,
3054 0,
3055 &[Some(20000)],
3056 Chain::Ethereum,
3057 100,
3058 );
3059 let eth = Token::new(
3060 &Bytes::from_str("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE").unwrap(),
3061 "ETH",
3062 18,
3063 0,
3064 &[Some(2000)],
3065 Chain::Ethereum,
3066 100,
3067 );
3068 let pool = FluidV1::new(
3069 &Bytes::from_str("0x0B1a513ee24972DAEf112bC777a5610d4325C9e7").unwrap(),
3070 &wsteth,
3071 ð,
3072 CollateralReserves {
3073 token0_real_reserves: U256::from(4431191840536456u128),
3074 token1_real_reserves: U256::from(13105569017021951u128),
3075 token0_imaginary_reserves: U256::from(20263646714209556492u128),
3076 token1_imaginary_reserves: U256::from(24624319733997222300u128),
3077 },
3078 DebtReserves {
3079 token0_real_reserves: U256::from(3958052320699256u128),
3080 token1_real_reserves: U256::from(11706224851989005u128),
3081 token0_imaginary_reserves: U256::from(18100000404581051720u128),
3082 token1_imaginary_reserves: U256::from(21995063545785045888u128),
3083 },
3084 DexLimits {
3085 borrowable_token0: hard_limit(4431191840536456767040),
3086 borrowable_token1: hard_limit(6552784508510975527319),
3087 withdrawable_token0: hard_limit(4819160955805377144139),
3088 withdrawable_token1: hard_limit(6126272539623278413525),
3089 },
3090 U256::from_str("1215727283480584508000000000").unwrap(),
3091 U256::from(68),
3092 1759795200,
3093 );
3094 (wsteth, eth, pool)
3095 }
3096
3097 #[test]
3098 fn test_spot_price() {
3099 let (wsteth, eth, pool) = wsteth_eth_pool_23526115();
3100 let exp_spot0 = 1.21519682; let exp_spot1 = 0.82291191; let spot0 = pool.spot_price(&wsteth, ð).unwrap();
3105 let spot1 = pool.spot_price(ð, &wsteth).unwrap();
3106
3107 let rel_err0 = (spot0 - exp_spot0).abs() / exp_spot0;
3108 let rel_err1 = (spot1 - exp_spot1).abs() / exp_spot1;
3109
3110 assert!(
3111 rel_err0 < 1e-4,
3112 "spot0 mismatch: got {spot0}, expected {exp_spot0}, relative error: {rel_err0}"
3113 );
3114 assert!(
3115 rel_err1 < 1e-4,
3116 "spot1 mismatch: got {spot1}, expected {exp_spot1}, relative error: {rel_err1}"
3117 );
3118 }
3119
3120 #[test]
3121 fn test_get_amount_out_zero2one() {
3122 let (wsteth, eth, pool) = wsteth_eth_pool_23526115();
3123 let amount_in = BigUint::from_str_radix("100000000000000", 10).unwrap();
3124 let exp_amount_out = BigUint::from_str_radix("121511421000000", 10).unwrap();
3126
3127 let res = pool
3128 .get_amount_out(amount_in, &wsteth, ð)
3129 .unwrap();
3130
3131 assert_eq!(res.amount, exp_amount_out);
3132 }
3133
3134 #[test]
3135 fn test_get_amount_out_one2zero() {
3136 let (wsteth, eth, pool) = wsteth_eth_pool_23526115();
3137 let amount_in = BigUint::from_str_radix("100000000000000", 10).unwrap();
3138 let exp_amount_out = BigUint::from_str_radix("82285598000000", 10).unwrap();
3140
3141 let res = pool
3142 .get_amount_out(amount_in, ð, &wsteth)
3143 .unwrap();
3144 assert_eq!(res.amount, exp_amount_out);
3145 }
3146
3147 #[test]
3148 fn get_limits_zero2one() {
3149 let (wsteth, eth, pool) = wsteth_eth_pool_23526115();
3150
3151 let (max_amount_in, _) = pool
3152 .get_limits(wsteth.address.clone(), eth.address.clone())
3153 .unwrap();
3154 let max_amount_onchain_test =
3155 BigUint::from_str_radix("10200000000000000000000", 10).unwrap();
3157
3158 let _ = pool
3159 .get_amount_out(max_amount_in.clone(), &wsteth, ð)
3160 .unwrap();
3161 assert!(max_amount_in < max_amount_onchain_test);
3162 }
3163
3164 #[test]
3165 fn get_limits_one2zero() {
3166 let (wsteth, eth, pool) = wsteth_eth_pool_23526115();
3167
3168 let (max_amount_in, _) = pool
3169 .get_limits(eth.address.clone(), wsteth.address.clone())
3170 .unwrap();
3171 let max_amount_onchain_test =
3172 BigUint::from_str_radix("10192694739404003000000", 10).unwrap();
3174
3175 let _ = pool
3176 .get_amount_out(max_amount_in.clone(), ð, &wsteth)
3177 .unwrap();
3178
3179 assert!(max_amount_in < max_amount_onchain_test);
3180 }
3181}