@paraswap/dex-lib 3.11.5-fluid-dex-changes.2 → 3.11.5

package/src/dex/fluid-dex/fluid-dex.ts

@@ -20,8 +20,6 @@ import {
   FluidDexData,
   FluidDexPool,
   Pool,
-  DexLimits,
-  TokenLimit,
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
 import FluidDexPoolABI from '../../abi/fluid-dex/fluid-dex.abi.json';
@@ -147,6 +145,8 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
+    if (side === SwapSide.BUY) return [];
+
     const pool = this.getPoolByTokenPair(srcToken.address, destToken.address);
     return pool ? [pool.id] : [];
   }
@@ -187,53 +187,42 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     try {
       if (srcToken.address.toLowerCase() === destToken.address.toLowerCase())
         return null;
+
+      if (side === SwapSide.BUY) return null;
       // Get the pool to use.
       const pool = this.getPoolByTokenPair(srcToken.address, destToken.address);
       if (!pool) return null;
+
       // Make sure the pool meets the optional limitPools filter.
       if (limitPools && !limitPools.includes(pool.id)) return null;
 
       const liquidityProxyState = await this.liquidityProxy.getStateOrGenerate(
         blockNumber,
       );
+
       const currentPoolReserves = liquidityProxyState.poolsReserves.find(
         poolReserve =>
           poolReserve.pool.toLowerCase() === pool.address.toLowerCase(),
       );
-      if (!currentPoolReserves) {
-        return null;
-      }
+      if (!currentPoolReserves) return null;
+
       const prices = amounts.map(amount => {
-        if (side === SwapSide.SELL) {
-          return this.swapIn(
-            srcToken.address.toLowerCase() === pool.token0.toLowerCase(),
-            amount,
-            currentPoolReserves.collateralReserves,
-            currentPoolReserves.debtReserves,
-            srcToken.decimals,
-            destToken.decimals,
-            BigInt(currentPoolReserves.fee),
-            currentPoolReserves.dexLimits,
-            Math.floor(Date.now() / 1000),
-          );
-        } else {
-          return this.swapOut(
-            srcToken.address.toLowerCase() === pool.token0.toLowerCase(),
-            amount,
-            currentPoolReserves.collateralReserves,
-            currentPoolReserves.debtReserves,
-            srcToken.decimals,
-            destToken.decimals,
-            BigInt(currentPoolReserves.fee),
-            currentPoolReserves.dexLimits,
-            Math.floor(Date.now() / 1000),
-          );
-        }
+        return this.swapIn(
+          srcToken.address.toLowerCase() === pool.token0.toLowerCase(),
+          amount,
+          currentPoolReserves.collateralReserves,
+          currentPoolReserves.debtReserves,
+          srcToken.decimals,
+          destToken.decimals,
+          BigInt(currentPoolReserves.fee),
+        );
       });
       return [
         {
           prices: prices,
-          unit: getBigIntPow(destToken.decimals),
+          unit: getBigIntPow(
+            (side === SwapSide.SELL ? destToken : srcToken).decimals,
+          ),
           data: {},
           exchange: this.dexKey,
           poolIdentifier: pool.id,
@@ -248,6 +237,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
         }, ${side}:`,
         e,
       );
+
       return null;
     }
   }
@@ -269,6 +259,8 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     data: FluidDexData,
     side: SwapSide,
   ): AdapterExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
     // Encode here the payload for adapter
     const payload = '';
     const pool = this.getPoolByTokenPair(srcToken, destToken);
@@ -301,40 +293,35 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     context: Context,
     executorAddress: Address,
   ): Promise<DexExchangeParam> {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
     let args: any;
     let returnAmountPos: number | undefined;
 
-    const method = side === SwapSide.SELL ? 'swapIn' : 'swapOut';
+    const method = 'swapIn';
 
     returnAmountPos = extractReturnAmountPosition(
       this.fluidDexPoolIface,
       method,
-      side === SwapSide.SELL ? 'amountOut_' : 'amountIn_',
+      'amountOut_',
     );
 
     const pool = this.getPoolByTokenPair(srcToken, destToken);
 
-    if (side === SwapSide.SELL) {
-      if (pool!.token0.toLowerCase() !== srcToken.toLowerCase()) {
-        args = [false, BigInt(srcAmount), BigInt(destAmount), recipient];
-      } else {
-        args = [true, BigInt(srcAmount), BigInt(destAmount), recipient];
-      }
+    if (pool!.token0.toLowerCase() !== srcToken.toLowerCase()) {
+      args = [false, BigInt(srcAmount), BigInt(destAmount), recipient];
     } else {
-      if (pool!.token0.toLowerCase() !== srcToken.toLowerCase()) {
-        args = [false, BigInt(destAmount), BigInt(srcAmount), recipient];
-      } else {
-        args = [true, BigInt(destAmount), BigInt(srcAmount), recipient];
-      }
+      args = [true, BigInt(srcAmount), BigInt(destAmount), recipient];
     }
+
     const swapData = this.fluidDexPoolIface.encodeFunctionData(method, args);
+
     return {
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: pool!.address,
       returnAmountPos,
-      sendEthButSupportsInsertFromAmount: true,
     };
   }
 
@@ -348,7 +335,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @param outDecimals - The number of decimals for the output token.
    * @returns The calculated output amount (as a BigInt).
    */
-  public swapIn(
+  private swapIn(
     swap0To1: boolean,
     amountIn: bigint,
     colReserves: CollateralReserves,
@@ -356,8 +343,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     inDecimals: number,
     outDecimals: number,
     fee: bigint,
-    currentLimits: DexLimits,
-    syncTime: number,
   ): bigint {
     if (amountIn === 0n) {
       return 0n; // Return 0 if input amount is 0
@@ -369,19 +354,17 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       return 0n;
     }
     const amountInAdjusted =
-      (((amountIn * (this.FEE_100_PERCENT - fee)) / this.FEE_100_PERCENT) *
-        BigInt(10 ** 12)) /
-      BigInt(10 ** inDecimals);
+      (amountIn * BigInt(10 ** 12)) / BigInt(10 ** inDecimals);
+
     const amountOut = this.swapInAdjusted(
       swap0To1,
-      amountInAdjusted,
+      amountInAdjusted, // Convert back to number for internal calculations
       colReserves,
       debtReserves,
-      outDecimals,
-      currentLimits,
-      syncTime,
+      fee,
     );
-    return (amountOut * BigInt(10 ** outDecimals)) / BigInt(10 ** 12);
+    const result = (amountOut * BigInt(10 ** outDecimals)) / BigInt(10 ** 12);
+    return result;
   }
 
   /**
@@ -392,14 +375,12 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @param debtReserves - The reserves of the debt pool.
    * @returns The calculated output amount.
    */
-  public swapInAdjusted(
+  private swapInAdjusted(
     swap0To1: boolean,
     amountToSwap: bigint,
     colReserves: CollateralReserves,
     debtReserves: DebtReserves,
-    outDecimals: number,
-    currentLimits: DexLimits,
-    syncTime: number,
+    fee: bigint,
   ): bigint {
     const {
       token0RealReserves,
@@ -407,6 +388,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       token0ImaginaryReserves,
       token1ImaginaryReserves,
     } = colReserves;
+
     const {
       token0RealReserves: debtToken0RealReserves,
       token1RealReserves: debtToken1RealReserves,
@@ -416,21 +398,26 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
 
     // Check if all reserves of collateral pool are greater than 0
     const colPoolEnabled =
-      token0RealReserves > 0 &&
-      token1RealReserves > 0 &&
-      token0ImaginaryReserves > 0 &&
-      token1ImaginaryReserves > 0;
+      token0RealReserves > BigInt(0) &&
+      token1RealReserves > BigInt(0) &&
+      token0ImaginaryReserves > BigInt(0) &&
+      token1ImaginaryReserves > BigInt(0);
 
     // Check if all reserves of debt pool are greater than 0
     const debtPoolEnabled =
-      debtToken0RealReserves > 0 &&
-      debtToken1RealReserves > 0 &&
-      debtToken0ImaginaryReserves > 0 &&
-      debtToken1ImaginaryReserves > 0;
+      debtToken0RealReserves > BigInt(0) &&
+      debtToken1RealReserves > BigInt(0) &&
+      debtToken0ImaginaryReserves > BigInt(0) &&
+      debtToken1ImaginaryReserves > BigInt(0);
 
-    let colReserveIn, colReserveOut, debtReserveIn, debtReserveOut;
-    let colIReserveIn, colIReserveOut, debtIReserveIn, debtIReserveOut;
-    let borrowable, withdrawable;
+    let colReserveIn: bigint,
+      colReserveOut: bigint,
+      debtReserveIn: bigint,
+      debtReserveOut: bigint;
+    let colIReserveIn: bigint,
+      colIReserveOut: bigint,
+      debtIReserveIn: bigint,
+      debtIReserveOut: bigint;
 
     if (swap0To1) {
       colReserveIn = token0RealReserves;
@@ -441,14 +428,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       debtReserveOut = debtToken1RealReserves;
       debtIReserveIn = debtToken0ImaginaryReserves;
       debtIReserveOut = debtToken1ImaginaryReserves;
-      borrowable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.borrowableToken1,
-      );
-      withdrawable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.withdrawableToken1,
-      );
     } else {
       colReserveIn = token1RealReserves;
       colReserveOut = token0RealReserves;
@@ -458,21 +437,8 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       debtReserveOut = debtToken0RealReserves;
       debtIReserveIn = debtToken1ImaginaryReserves;
       debtIReserveOut = debtToken0ImaginaryReserves;
-      borrowable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.borrowableToken0,
-      );
-      withdrawable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.withdrawableToken0,
-      );
     }
 
-    // bring borrowable and withdrawable from token decimals to 1e12 decimals, same as amounts
-    borrowable = (borrowable * BigInt(10 ** 12)) / BigInt(10 ** outDecimals);
-    withdrawable =
-      (withdrawable * BigInt(10 ** 12)) / BigInt(10 ** outDecimals);
-
     let a: bigint;
     if (colPoolEnabled && debtPoolEnabled) {
       a = this.swapRoutingIn(
@@ -483,41 +449,39 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
         debtIReserveIn,
       );
     } else if (debtPoolEnabled) {
-      a = -1n; // Route from debt pool
+      a = BigInt(-1); // Route from debt pool
     } else if (colPoolEnabled) {
-      a = amountToSwap + 1n; // Route from collateral pool
+      a = amountToSwap + BigInt(1); // Route from collateral pool
     } else {
       throw new Error('No pools are enabled');
     }
 
-    let amountOutCollateral = 0n;
-    let amountOutDebt = 0n;
-    let amountInCollateral = 0n;
-    let amountInDebt = 0n;
+    let amountOutCollateral = BigInt(0);
+    let amountOutDebt = BigInt(0);
 
-    if (a <= 0n) {
+    if (a <= BigInt(0)) {
       // Entire trade routes through debt pool
-      amountInDebt = amountToSwap;
       amountOutDebt = this.getAmountOut(
-        amountToSwap,
+        this.applyFee(amountToSwap, fee),
         debtIReserveIn,
         debtIReserveOut,
       );
     } else if (a >= amountToSwap) {
       // Entire trade routes through collateral pool
-      amountInCollateral = amountToSwap;
       amountOutCollateral = this.getAmountOut(
-        amountToSwap,
+        this.applyFee(amountToSwap, fee),
         colIReserveIn,
         colIReserveOut,
       );
     } else {
       // Trade routes through both pools
-      amountInCollateral = a;
-      amountOutCollateral = this.getAmountOut(a, colIReserveIn, colIReserveOut);
-      amountInDebt = amountToSwap - a;
+      amountOutCollateral = this.getAmountOut(
+        this.applyFee(a, fee),
+        colIReserveIn,
+        colIReserveOut,
+      );
       amountOutDebt = this.getAmountOut(
-        amountInDebt,
+        this.applyFee(amountToSwap - a, fee),
         debtIReserveIn,
         debtIReserveOut,
       );
@@ -526,91 +490,17 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     if (amountOutDebt > debtReserveOut) {
       return 0n;
     }
-    if (amountOutDebt > borrowable) {
-      return 0n;
-    }
 
     if (amountOutCollateral > colReserveOut) {
       return 0n;
     }
-
-    if (amountOutCollateral > withdrawable) {
-      return 0n;
-    }
-
-    // For price calculations, we'll use a precision factor for bigint division
-    const PRECISION = 1000000000000000000000000000n; // 1e27
-
-    let oldPrice: bigint;
-    let newPrice: bigint;
-
-    if (amountInCollateral > amountInDebt) {
-      // new pool price from col pool
-      oldPrice = swap0To1
-        ? (colIReserveOut * PRECISION) / colIReserveIn
-        : (colIReserveIn * PRECISION) / colIReserveOut;
-
-      newPrice = swap0To1
-        ? ((colIReserveOut - amountOutCollateral) * PRECISION) /
-          (colIReserveIn + amountInCollateral)
-        : ((colIReserveIn + amountInCollateral) * PRECISION) /
-          (colIReserveOut - amountOutCollateral);
-    } else {
-      // new pool price from debt pool
-      oldPrice = swap0To1
-        ? (debtIReserveOut * PRECISION) / debtIReserveIn
-        : (debtIReserveIn * PRECISION) / debtIReserveOut;
-
-      newPrice = swap0To1
-        ? ((debtIReserveOut - amountOutDebt) * PRECISION) /
-          (debtIReserveIn + amountInDebt)
-        : ((debtIReserveIn + amountInDebt) * PRECISION) /
-          (debtIReserveOut - amountOutDebt);
-    }
-    // Calculate price difference using bigint arithmetic
-    const MAX_PRICE_DIFF = 5n; // 5%
-    const priceDiff =
-      oldPrice > newPrice ? oldPrice - newPrice : newPrice - oldPrice;
-    const maxAllowedDiff = (oldPrice * MAX_PRICE_DIFF) / 100n;
-
-    if (priceDiff > maxAllowedDiff) {
-      return 0n;
-    }
     const totalAmountOut = amountOutCollateral + amountOutDebt;
 
     return totalAmountOut;
   }
 
-  /**
-   * Calculates the currently available swappable amount for a token limit considering expansion since last syncTime.
-   * @param syncTime - timestamp in seconds when the limits were synced
-   * @param limit - token limit object containing available amount, expandsTo amount, and expandDuration
-   * @returns The calculated available swappable amount (borrowable or withdrawable)
-   */
-  public getExpandedLimit(syncTime: number, limit: TokenLimit): bigint {
-    const currentTime = Math.floor(Date.now() / 1000); // convert milliseconds to seconds
-    const elapsedTime = currentTime - syncTime;
-    limit.expandsDuration = limit.expandsDuration || 0n;
-    if (elapsedTime < 10n) {
-      // if almost no time has elapsed, return available amount
-      return limit.available;
-    }
-
-    if (elapsedTime >= limit.expandsDuration) {
-      // if duration has passed, return max amount
-      return limit.expandsTo;
-    }
-
-    // Calculate expansion ratio using bigint arithmetic
-    // Multiply by a large factor for precision in integer arithmetic
-    const PRECISION = 1000000;
-    const ratio = BigInt(elapsedTime * PRECISION) / limit.expandsDuration;
-
-    // Calculate expanded amount with precision factor
-    const expansion =
-      ((limit.expandsTo - limit.available) * ratio) / BigInt(PRECISION);
-    const expandedAmount = limit.available + expansion;
-    return expandedAmount;
+  applyFee(amount: bigint, fee: bigint): bigint {
+    return (amount * (this.FEE_100_PERCENT - fee)) / this.FEE_100_PERCENT;
   }
 
   /**
@@ -620,7 +510,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @param iReserveOut - Imaginary token reserve of output amount.
    * @returns The maximum output amount of the other asset.
    */
-  public getAmountOut(
+  private getAmountOut(
     amountIn: bigint,
     iReserveIn: bigint,
     iReserveOut: bigint,
@@ -642,7 +532,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @param iReserveOut - Imaginary token reserve of output amount.
    * @returns The input amount of the other asset.
    */
-  public getAmountIn(
+  private getAmountIn(
     amountOut: bigint,
     iReserveIn: bigint,
     iReserveOut: bigint,
@@ -667,7 +557,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @note If a > t then entire trade route through col pool and col pool arbitrage with debt pool.
    * @note If a > 0 & a < t then swap will route through both pools.
    */
-  public swapRoutingOut(
+  private swapRoutingOut(
     t: bigint,
     x: bigint,
     y: bigint,
@@ -704,7 +594,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @note If a > t then entire trade route through col pool and col pool arbitrage with debt pool.
    * @note If a > 0 & a < t then swap will route through both pools.
    */
-  public swapRoutingIn(
+  private swapRoutingIn(
     t: bigint,
     x: bigint,
     y: bigint,
@@ -734,7 +624,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @param {number} fee - The fee for the swap. 1e4 = 1%
    * @returns {bigint} amountIn - The calculated input amount required for the swap.
    */
-  public swapOut(
+  private swapOut(
     swap0to1: boolean,
     amountOut: bigint,
     colReserves: CollateralReserves,
@@ -742,8 +632,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     inDecimals: number,
     outDecimals: number,
     fee: bigint,
-    currentLimits: DexLimits,
-    syncTime: number,
   ): bigint {
     const amountOutAdjusted =
       (amountOut * BigInt(10 ** 12)) / BigInt(10 ** outDecimals);
@@ -752,19 +640,15 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       amountOutAdjusted,
       colReserves,
       debtReserves,
-      outDecimals,
-      currentLimits,
-      syncTime,
     );
 
-    if (amountIn == 2n ** 256n - 1n) {
-      return amountIn;
-    }
-    const ans =
-      (amountIn * this.FEE_100_PERCENT * BigInt(10 ** inDecimals)) /
-      BigInt(10 ** 12) /
-      (this.FEE_100_PERCENT - fee);
-    return ans;
+    const FEE_100_PERCENT = BigInt(1e6); // Assuming this constant is defined elsewhere
+
+    const result =
+      ((amountIn * FEE_100_PERCENT) / (FEE_100_PERCENT - fee)) *
+      BigInt(10 ** (inDecimals - 12));
+
+    return result;
   }
 
   /**
@@ -775,18 +659,12 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
    * @param {DebtReserves} debtReserves - The reserves of the debt pool.
    * @returns {bigint} The calculated input amount required for the swap.
    */
-  public swapOutAdjusted(
+  private swapOutAdjusted(
     swap0to1: boolean,
     amountOut: bigint,
     colReserves: CollateralReserves,
     debtReserves: DebtReserves,
-    outDecimals: number,
-    currentLimits: DexLimits,
-    syncTime: number,
   ): bigint {
-    if (amountOut === 0n) {
-      return 0n; // Return 0 if output amount is 0
-    }
     const {
       token0RealReserves,
       token1RealReserves,
@@ -803,17 +681,17 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
 
     // Check if all reserves of collateral pool are greater than 0
     const colPoolEnabled =
-      token0RealReserves > BigInt(0) &&
-      token1RealReserves > BigInt(0) &&
-      token0ImaginaryReserves > BigInt(0) &&
-      token1ImaginaryReserves > BigInt(0);
+      token0RealReserves > 0n &&
+      token1RealReserves > 0n &&
+      token0ImaginaryReserves > 0n &&
+      token1ImaginaryReserves > 0n;
 
     // Check if all reserves of debt pool are greater than 0
     const debtPoolEnabled =
-      debtToken0RealReserves > BigInt(0) &&
-      debtToken1RealReserves > BigInt(0) &&
-      debtToken0ImaginaryReserves > BigInt(0) &&
-      debtToken1ImaginaryReserves > BigInt(0);
+      debtToken0RealReserves > 0n &&
+      debtToken1RealReserves > 0n &&
+      debtToken0ImaginaryReserves > 0n &&
+      debtToken1ImaginaryReserves > 0n;
 
     let colReserveIn: bigint,
       colReserveOut: bigint,
@@ -823,7 +701,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       colIReserveOut: bigint,
       debtIReserveIn: bigint,
       debtIReserveOut: bigint;
-    let borrowable: bigint, withdrawable: bigint;
 
     if (swap0to1) {
       colReserveIn = token0RealReserves;
@@ -834,14 +711,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       debtReserveOut = debtToken1RealReserves;
       debtIReserveIn = debtToken0ImaginaryReserves;
       debtIReserveOut = debtToken1ImaginaryReserves;
-      borrowable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.borrowableToken1,
-      );
-      withdrawable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.withdrawableToken1,
-      );
     } else {
       colReserveIn = token1RealReserves;
       colReserveOut = token0RealReserves;
@@ -851,21 +720,8 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       debtReserveOut = debtToken0RealReserves;
       debtIReserveIn = debtToken1ImaginaryReserves;
       debtIReserveOut = debtToken0ImaginaryReserves;
-      borrowable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.borrowableToken0,
-      );
-      withdrawable = this.getExpandedLimit(
-        syncTime,
-        currentLimits.withdrawableToken0,
-      );
     }
 
-    // bring borrowable and withdrawable from token decimals to 1e12 decimals, same as amounts
-    borrowable = (borrowable * BigInt(10 ** 12)) / BigInt(10 ** outDecimals);
-    withdrawable =
-      (withdrawable * BigInt(10 ** 12)) / BigInt(10 ** outDecimals);
-
     let a: bigint;
     if (colPoolEnabled && debtPoolEnabled) {
       a = this.swapRoutingOut(
@@ -876,106 +732,51 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
         debtIReserveOut,
       );
     } else if (debtPoolEnabled) {
-      a = BigInt(-1); // Route from debt pool
+      a = -1n; // Route from debt pool
     } else if (colPoolEnabled) {
-      a = amountOut + BigInt(1); // Route from collateral pool
+      a = amountOut + 1n; // Route from collateral pool
     } else {
       throw new Error('No pools are enabled');
     }
 
-    let amountInCollateral: bigint = BigInt(0);
-    let amountInDebt: bigint = BigInt(0);
-    let amountOutCollateral: bigint = BigInt(0);
-    let amountOutDebt: bigint = BigInt(0);
+    let amountInCollateral = 0n;
+    let amountInDebt = 0n;
 
-    if (a <= BigInt(0)) {
+    if (a <= 0n) {
       // Entire trade routes through debt pool
-      amountOutDebt = amountOut;
       amountInDebt = this.getAmountIn(
         amountOut,
         debtIReserveIn,
         debtIReserveOut,
       );
       if (amountOut > debtReserveOut) {
-        return 2n ** 256n - 1n;
-      }
-      if (amountOut > borrowable) {
-        return 2n ** 256n - 1n;
+        return 2n ** 64n - 1n; // BigInt max value
       }
     } else if (a >= amountOut) {
       // Entire trade routes through collateral pool
-      amountOutCollateral = amountOut;
       amountInCollateral = this.getAmountIn(
         amountOut,
         colIReserveIn,
         colIReserveOut,
       );
       if (amountOut > colReserveOut) {
-        return 2n ** 256n - 1n;
-      }
-      if (amountOut > withdrawable) {
-        return 2n ** 256n - 1n;
+        return 2n ** 64n - 1n; // BigInt max value
       }
     } else {
       // Trade routes through both pools
-      amountOutCollateral = a;
       amountInCollateral = this.getAmountIn(a, colIReserveIn, colIReserveOut);
-      amountOutDebt = amountOut - a;
       amountInDebt = this.getAmountIn(
-        amountOutDebt,
+        amountOut - a,
         debtIReserveIn,
         debtIReserveOut,
       );
-      if (amountOutDebt > debtReserveOut || a > colReserveOut) {
-        return 2n ** 256n - 1n;
-      }
-      if (amountOutDebt > borrowable || a > withdrawable) {
-        return 2n ** 256n - 1n;
+      if (amountOut - a > debtReserveOut || a > debtReserveOut) {
+        return 2n ** 64n - 1n; // BigInt max value
       }
     }
 
-    let oldPrice: bigint;
-    let newPrice: bigint;
-    const SCALE = BigInt(1e27);
-
-    // from whatever pool higher amount of swap is routing we are taking that as final price, does not matter much because both pools final price should be same
-    if (amountOutCollateral > amountOutDebt) {
-      // new pool price from col pool
-      oldPrice = swap0to1
-        ? (colIReserveOut * SCALE) / colIReserveIn
-        : (colIReserveIn * SCALE) / colIReserveOut;
-      newPrice = swap0to1
-        ? ((colIReserveOut - amountOutCollateral) * SCALE) /
-          (colIReserveIn + amountInCollateral)
-        : ((colIReserveIn + amountInCollateral) * SCALE) /
-          (colIReserveOut - amountOutCollateral);
-    } else {
-      // new pool price from debt pool
-      oldPrice = swap0to1
-        ? (debtIReserveOut * SCALE) / debtIReserveIn
-        : (debtIReserveIn * SCALE) / debtIReserveOut;
-      newPrice = swap0to1
-        ? ((debtIReserveOut - amountOutDebt) * SCALE) /
-          (debtIReserveIn + amountInDebt)
-        : ((debtIReserveIn + amountInDebt) * SCALE) /
-          (debtIReserveOut - amountOutDebt);
-    }
-
-    const MAX_PRICE_DIFF = BigInt(5); // 5%
-    if (
-      this.abs(oldPrice - newPrice) >
-      (oldPrice / BigInt(100)) * MAX_PRICE_DIFF
-    ) {
-      // if price diff is > 5% then swap would revert.
-      return 2n ** 256n - 1n;
-    }
-
     const totalAmountIn = amountInCollateral + amountInDebt;
 
     return totalAmountIn;
   }
-
-  private abs(value: bigint): bigint {
-    return value < 0 ? -value : value;
-  }
 }