Skip to main content

tycho_simulation/evm/protocol/fluid/
v1.rs

1/// FluidV1 simulation logic.
2///
3/// This implementation is a port from the [Kyberswap reference implementation](https://github.com/KyberNetwork/kyberswap-dex-lib/blob/main/pkg/liquidity-source/fluid/dex-t1/pool_simulator.go)
4/// functions and errors are ported equivalently and then used to implement the ProtocolSim
5/// interface.
6///
7/// ## Differences
8/// - Native ETH: Tycho uses a zero-byte address while Fluid uses 0xeee... address
9/// - Limits: Tycho uses binary search to find limits that will actually execute
10/// - State: Tycho uses the local VM to retrieve and update the state of each pool
11use 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]); // 5
51    pub const MIN_SWAP_LIQUIDITY: U256 = U256::from_limbs([8500, 0, 0, 0]); // 8500
52    pub const SIX_DECIMALS: U256 = U256::from_limbs([1000000, 0, 0, 0]); // 1e6
53    pub const TWO_DECIMALS: U256 = U256::from_limbs([100, 0, 0, 0]); // 1e2
54    pub const B_I1E18: U256 = U256::from_limbs([0x0DE0B6B3A7640000, 0, 0, 0]); // 1e18
55    pub const B_I1E27: U256 = U256::from_limbs([0x9fd0803ce8000000, 0x33b2e3c, 0, 0]); // 1e27
56    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        // potentially flip token0 and token1 since ETH address is different from our eth marker
164        // address
165        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    /// Returns the input amount, fee included, that moves both sub-pools' marginal prices to
197    /// `target`, treating each as a constant-product AMM over its imaginary reserves. Returns
198    /// `None` on overflow or a zero target.
199    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        // `spot_price` reports the reserve ratio divided by `1 - fee`.
222        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        // Imaginary reserves hold both tokens at 12 decimals.
227        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            // The marginal price is k / reserve_in^2, so the new reserve_in is sqrt(k / price).
238            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    /// Returns the swap that moves the spot price down into `[target, target * (1 + tolerance)]`.
258    /// A target equal to the spot price gives a zero swap. A target above it is `InvalidInput`.
259    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        // The numerical search reports pool limit errors, and it corrects the closed form when
279        // the sub-pools start at different prices.
280        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                // Allow f64 rounding noise on both sides of the band.
286                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 is in basis points: fee / FEE_PERCENT_PRECISION / 100
320        // e.g., fee=68 means 68/10000/100 = 0.000068 = 0.0068%
321        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    /// Decodes `pool_reserves_adjusted` with its eight-byte `block_timestamp` when present.
490    /// A missing timestamp fails; only missing reserves fall back to confirmed state.
491    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
573/// Generic binary search for the largest `U256` input that doesn't return an error.
574///
575/// # Parameters
576/// - `upper_bound`: The maximum value to test.
577/// - `delta`: Stop searching when `high - low < delta`.
578/// - `f`: A closure that takes a `U256` input and returns `Result<T, E>`.
579///
580/// # Returns
581/// The largest input value for which `f(input)` succeeded.
582pub 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, &current_limits.borrowable_token1),
646            get_expanded_limit(sync_time, &current_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, &current_limits.borrowable_token0),
659            get_expanded_limit(sync_time, &current_limits.withdrawable_token0),
660        )
661    };
662
663    // Adjust borrowable and withdrawable amounts to match output decimals
664    let borrowable = to_adjusted_amount(borrowable, out_decimals);
665    let withdrawable = to_adjusted_amount(withdrawable, out_decimals);
666
667    // Check if all reserves are greater than 0
668    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 // Route from debt pool
692    } else if col_pool_enabled {
693        amount_to_swap + U256::ONE // Route from collateral pool
694    } 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        // Entire trade routes through debt pool
703        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        // Entire trade routes through collateral pool
707        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        // Trade routes through both pools
712        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, &current_limits.borrowable_token1),
870            get_expanded_limit(sync_time, &current_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, &current_limits.borrowable_token0),
883            get_expanded_limit(sync_time, &current_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
1064/// Calculates how much of a swap should go through the collateral pool.
1065///
1066/// # Parameters
1067/// - `t`: Total amount in.
1068/// - `x`: Imaginary reserves of token out of collateral.
1069/// - `y`: Imaginary reserves of token in of collateral.
1070/// - `x2`: Imaginary reserves of token out of debt.
1071/// - `y2`: Imaginary reserves of token in of debt.
1072///
1073/// # Returns
1074/// - `a`: How much of the swap should go through the collateral pool. The remaining amount will go
1075///   through the debt pool.
1076///
1077/// # Notes
1078/// - If `a < 0`, the entire trade routes through the debt pool and debt pool arbitrages with
1079///   collateral pool.
1080/// - If `a > t`, the entire trade routes through the collateral pool and collateral pool arbitrages
1081///   with debt pool.
1082/// - If `a > 0 && a < t`, the swap will route through both pools.
1083fn 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/// Calculates how much of a swap should go through the collateral pool for an output amount.
1093///
1094/// # Notes
1095/// - If `a < 0` → entire trade goes through debt pool.
1096/// - If `a > t` → entire trade goes through collateral pool.
1097/// - If `0 < a < t` → swap routes through both pools.
1098#[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/// Given an output amount of asset and reserves, returns the input amount of the other asset.
1114///
1115/// Formula: (amount_out * iReserveIn) / (iReserveOut - amount_out)
1116#[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
1132/// Converts an adjusted amount to the original precision by compensating for decimal differences.
1133///
1134/// # Arguments
1135/// * `adjusted_amount` - The amount adjusted to DexAmountsDecimals.
1136/// * `decimals` - The original token decimals.
1137/// * `dex_amounts_decimals` - The reference decimals used by DEX amounts.
1138///
1139/// # Returns
1140/// * The amount scaled back to the original decimals.
1141fn 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        // Divide by 10^(-diff)
1148        let divisor = ten_pow(-diff);
1149        adjusted_amount / divisor
1150    } else {
1151        // Multiply by 10^(diff)
1152        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
1161/// Checks if token0 reserves are sufficient compared to token1 reserves.
1162///
1163/// This prevents reserve imbalance and ensures price calculations remain stable and precise.
1164///
1165/// # Arguments
1166/// * `token0_reserves` - Reserves of token0.
1167/// * `token1_reserves` - Reserves of token1.
1168/// * `price` - Current price used in the reserve validation.
1169///
1170/// # Returns
1171/// Returns `false` if token0 reserves are too low, `true` otherwise.
1172///
1173/// # Formula
1174/// ```text
1175/// token0_reserves >= (token1_reserves * 1e27) / (price * MIN_SWAP_LIQUIDITY)
1176/// ```
1177fn 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
1186/// Checks if token1 reserves are sufficient compared to token0 reserves.
1187///
1188/// This prevents reserve imbalance and ensures price calculations remain stable and precise.
1189///
1190/// # Arguments
1191/// * `token0_reserves` - Reserves of token0.
1192/// * `token1_reserves` - Reserves of token1.
1193/// * `price` - Current price used in the reserve validation.
1194///
1195/// # Returns
1196/// `false` if token1 reserves are too low, `true` otherwise.
1197///
1198/// # Formula
1199/// ```text
1200/// token1_reserves >= (token0_reserves * price) / (1e27 * MIN_SWAP_LIQUIDITY)
1201/// ```
1202fn 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
1208/// Calculates the currently available swappable amount for a token limit,
1209/// considering how much it has expanded since the last synchronization.
1210///
1211/// This models gradual limit recovery over time.
1212///
1213/// # Arguments
1214/// * `sync_time` — UNIX timestamp (in seconds) of the last synchronization.
1215/// * `limit` — The token limit definition.
1216///
1217/// # Returns
1218/// Returns the currently effective limit as a `U256`.
1219fn 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        // If almost no time has elapsed, return available amount
1230        return limit.available;
1231    }
1232
1233    if elapsed >= limit.expand_duration {
1234        // If full duration has passed, return max amount
1235        return limit.expands_to;
1236    }
1237
1238    // Linear interpolation:
1239    // expanded = available + (expands_to - available) * elapsed / expand_duration
1240    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
1248/// Returns updated copies of `CollateralReserves` and `DexLimits` based on swap direction.
1249///
1250/// # Note
1251/// Updates reserves and limits in-place.
1252fn 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        // token0 → token1 swap
1264        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        // token1 → token0 swap
1287        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        // Comment Ref #4327563287
1328        // if expandTo for borrowable and withdrawable match, that means they are a hard limit like
1329        // liquidity layer balance or utilization limit. In that case, the available swap
1330        // amount should increase by `amountIn` but it's not guaranteed because the actual
1331        // borrow limit / withdrawal limit could be the limiting factor now, which could be even
1332        // only +1 bigger. So not updating in amount to avoid any revert. The same applies on all
1333        // other similar cases in the code below. Note a swap would anyway trigger an event,
1334        // so the proper limits will be fetched shortly after the swap.
1335        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    // Step 1: Determine maxLimitReserves
1356    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    // Step 2: Calculate maxRealReserves
1363    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    // Step 3: Return the smaller of the two
1373    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            &eth,
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 // equivalent to -1 in Go logic for error handling
1588        } 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 // Special case: Route entirely from debt pool
1674        } else if col_pool_enabled {
1675            amount_out + U256::ONE // Special case: Route entirely from collateral pool
1676        } 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        // Values must come from the attribute bytes; a VM call would fail here because the
1723        // shared engine has no block set.
1724        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        // Pool reserves are recomputed from the new limits and reserves:
1756        // withdrawable + borrowable expands_to caps the summed real reserves.
1757        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, &eth)
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(), &eth, &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    // Real reserves cap the move at a few bps. The tolerance is below the move, so a wrong
1863    // amount leaves the band. One2zero needs a different center price to stay within limits.
1864    #[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(&params).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, &eth).unwrap();
1904        let params =
1905            target_price_params(&wsteth, &eth, to_price(spot * 1.01, &wsteth, &eth), 0.001);
1906
1907        let result = pool.query_pool_swap(&params);
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, &eth).unwrap();
1916        // spot is in [1, 2), so spot * 2^52 is an exact integer.
1917        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, &eth, target, 0.001);
1926
1927        let swap = pool.query_pool_swap(&params).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        // With 6 decimals the closed-form input rounds down, so the new spot price misses a zero
1936        // tolerance band.
1937        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(&params).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        // set custom reserves to trigger the error
1953        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(); // 300 wstETH
1956        let result = pool.get_amount_out(amount_in, &wsteth, &eth);
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), // 1e15
1975            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    /// Asserts that a swap produces the expected output amount.
2046    ///
2047    /// # Arguments
2048    /// - `swap0_to_1`: Direction of the swap.
2049    /// - `amount_in`: Total amount in.
2050    /// - `col_reserves`: Collateral reserves.
2051    /// - `debt_reserves`: Debt reserves.
2052    /// - `expected_amount_out`: Expected output amount as a string.
2053    /// - `in_decimals`: Decimals for the input token.
2054    /// - `out_decimals`: Decimals for the output token.
2055    /// - `limits`: Dex limits.
2056    /// - `sync_time`: Timestamp for syncing.
2057    #[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        // when limits hit
2135        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        // when expanded
2157        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        // when price diff hit
2180        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        // when reserves limit is hit
2202        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); // 1e12
2244        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; // ~6000 seconds earlier
2419
2420        // --- when limits hit ---
2421        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        // --- when expanded ---
2444        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        // --- when price diff hit ---
2468        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        // --- when reserves limit is hit ---
2491        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        // swap0To1 = true
2526        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        // swap0To1 = false
2539        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        // swap0To1 = true
2564        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        // swap0To1 = false
2577        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    /// Calculate reserves outside a price range
2609    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        // part1 = priceAtRange - geometricMeanPrice
2624        let part1 = price_at_range
2625            .checked_sub(geometric_mean_price)
2626            .expect("priceAtRange must be >= geometricMeanPrice");
2627
2628        // part2 = (geometricMeanPrice * reserveX + reserveY * 1e27) / (2 * part1)
2629        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        // part3 = reserveX * reserveY
2638        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        // Handle overflow
2647        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        // reserveXOutside = part2 + sqrt(part3 + part2^2)
2662        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        // reserveYOutside = (reserveXOutside * geometricMeanPrice) / 1e27
2675        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        // Calculate imaginary reserves for colReserves
2693        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        // Calculate imaginary reserves for debtReserves
2707        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        // --- Case: Swap amount triggers revert (14_905)
2727        let swap_amount = U256::from(14_905) * U256::from(10).pow(U256::from(12)); // decimals factor
2728        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        // --- Refresh reserves
2773        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            // The test relies on this price value, obtained by the previous failing calls setup
2792            //  note that this value is < B_I1E27 so the returned reserves here will be negative
2793            //  it's unclear if this is expected by the Kyberswap implementation but it seems
2794            //  more like the value 14_895 was found with this unwanted side effect in place.
2795            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        // --- Case: Swap amount should succeed (14_895)
2806        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)), /* 15_000 * 1e12 */
2856            token1_real_reserves: U256::from(2_000_000u64) * U256::from(10u64).pow(U256::from(12)), /* 2_000_000 * 1e12 */
2857            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        // price = 1.000001 * 1e27
2884        let price = U256::from_str("1000001000000000000000000000").unwrap();
2885
2886        // First reserves calculation
2887        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        // Swap amount where revert should hit
2910        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        // Refresh reserves
2953        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        // Swap amount where revert should NOT hit
2979        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    // Use this command to retrieve state for fluid pools:
3026    // ```bash
3027    // cast call 0xC93876C0EEd99645DD53937b25433e311881A27C \
3028    //  'getPoolReservesAdjusted(address)(address,address,address,uint256,uint256,(uint256,uint256,uint256),(uint256,uint256,uint256,uint256,uint256,uint256),((uint256,uint256,uint256),(uint256,uint256,uint256),(uint256,uint256,uint256),(uint256,uint256,uint256)))' \
3029    //  '0x0B1a513ee24972DAEf112bC777a5610d4325C9e7'
3030    // ```
3031    //
3032    // Use this command to get onchain estimates:
3033    //
3034    // ```bash
3035    // cast call -b 23526115 \
3036    //  0xC93876C0EEd99645DD53937b25433e311881A27C \
3037    //  'estimateSwapIn(address,bool,uint,uint)(uint)' \
3038    //  0x0B1a513ee24972DAEf112bC777a5610d4325C9e7 true 100000000000000 0
3039    // ```
3040
3041    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            &eth,
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        // derived via numerical estimates from onchain quotes
3101        let exp_spot0 = 1.21519682; // 1.21511419 adjusted by 0.0068% fee
3102        let exp_spot1 = 0.82291191; // 0.82228559 adjusted by 0.0068% fee
3103
3104        let spot0 = pool.spot_price(&wsteth, &eth).unwrap();
3105        let spot1 = pool.spot_price(&eth, &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        // onchain we get 121511419000000
3125        let exp_amount_out = BigUint::from_str_radix("121511421000000", 10).unwrap();
3126
3127        let res = pool
3128            .get_amount_out(amount_in, &wsteth, &eth)
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        // onchain we get 82285596000000
3139        let exp_amount_out = BigUint::from_str_radix("82285598000000", 10).unwrap();
3140
3141        let res = pool
3142            .get_amount_out(amount_in, &eth, &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            // 10.2k wsteth
3156            BigUint::from_str_radix("10200000000000000000000", 10).unwrap();
3157
3158        let _ = pool
3159            .get_amount_out(max_amount_in.clone(), &wsteth, &eth)
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            // 10.2k wsteth
3173            BigUint::from_str_radix("10192694739404003000000", 10).unwrap();
3174
3175        let _ = pool
3176            .get_amount_out(max_amount_in.clone(), &eth, &wsteth)
3177            .unwrap();
3178
3179        assert!(max_amount_in < max_amount_onchain_test);
3180    }
3181}