@paraswap/dex-lib 3.4.0 → 3.4.1

package/src/dex/swaap-v1/libraries/Num.ts

@@ -1,184 +0,0 @@
-import {
-  BI_MAX_INT,
-  BI_MAX_UINT256 as BI_MAX_UINT,
-} from '../../../bigint-constants';
-import { Const } from './Const';
-
-const _require = (b: boolean, message: string) => {
-  if (!b) throw new Error(message);
-};
-
-export class Num {
-  /**
-   * @dev Returns the addition of two signed integers, reverting on overflow.
-   */
-  static add(a: bigint, b: bigint): bigint {
-    const c = a + b;
-    _require(c <= BI_MAX_UINT, 'Errors.ADD_OVERFLOW');
-    return c;
-  }
-
-  /**
-   * @dev Returns the subtraction of two unsigned integers of 256 bits, reverting on overflow.
-   */
-  static sub(a: bigint, b: bigint): bigint {
-    _require(a >= 0n && b >= 0n, 'Errors.NEGATIVE_UINT');
-    _require(b <= a, 'Errors.SUB_OVERFLOW');
-    const c = a - b;
-    return c;
-  }
-
-  static toi(a: bigint): bigint {
-    return a / Const.ONE;
-  }
-
-  static floor(a: bigint): bigint {
-    return this.toi(a) * Const.ONE;
-  }
-
-  static subSign(a: bigint, b: bigint): [bigint, boolean] {
-    if (a >= b) {
-      return [a - b, false];
-    } else {
-      return [b - a, true];
-    }
-  }
-
-  static mul(a: bigint, b: bigint): bigint {
-    const c1 = a * b + Const.ONE / 2n;
-    // Second conditions is added in case c1 was an int256 (and not a uint256)
-    _require(c1 <= BI_MAX_UINT && c1 >= -BI_MAX_INT, 'Err.MATH_OVERFLOW');
-    return c1 / Const.ONE;
-  }
-
-  static mulTruncated(a: bigint, b: bigint): bigint {
-    const c0 = a * b;
-    _require(c0 <= BI_MAX_UINT, 'Err.MATH_OVERFLOW');
-    return c0 / Const.ONE;
-  }
-
-  static div(a: bigint, b: bigint): bigint {
-    const c1 = a * Const.ONE + b / 2n;
-    _require(c1 <= BI_MAX_UINT, 'Err.MATH_OVERFLOW');
-    return c1 / b;
-  }
-
-  static divTruncated(a: bigint, b: bigint): bigint {
-    const c0 = a * Const.ONE;
-    _require(c0 <= BI_MAX_UINT, 'Err.MATH_OVERFLOW');
-    return c0 / b;
-  }
-
-  // DSMath.wpow
-  static powi(a: bigint, n: bigint): bigint {
-    let z = n % 2n != 0n ? a : Const.ONE;
-
-    for (n /= 2n; n != 0n; n /= 2n) {
-      a = this.mul(a, a);
-
-      if (n % 2n != 0n) {
-        z = this.mul(z, a);
-      }
-    }
-    return z;
-  }
-
-  // Compute b^(e.w) by splitting it into (b^e)*(b^0.w).
-  // Use `powi` for `b^e` and `powK` for k iterations
-  // of approximation of b^0.w
-  static pow(base: bigint, exp: bigint): bigint {
-    _require(base >= Const.MIN_POW_BASE, 'Err.POW_BASE_TOO_LOW');
-    _require(base <= Const.MAX_POW_BASE, 'Err.POW_BASE_TOO_HIGH');
-
-    const whole = this.floor(exp);
-    const remain = exp - whole;
-
-    const wholePow = this.powi(base, this.toi(whole));
-
-    if (remain == 0n) {
-      return wholePow;
-    }
-
-    const partialResult = this.powApprox(base, remain, Const.POW_PRECISION);
-    return this.mul(wholePow, partialResult);
-  }
-
-  static powApprox(base: bigint, exp: bigint, precision: bigint): bigint {
-    // term 0:
-    const a = exp;
-    const [x, xneg] = this.subSign(base, Const.ONE);
-
-    let term = Const.ONE;
-    let sum = term;
-    let negative = false;
-
-    // term(k) = numer / denom
-    //         = (product(a - i - 1, i=1-->k) * x^k) / (k!)
-    // each iteration, multiply previous term by (a-(k-1)) * x / k
-    // continue until term is less than precision
-    for (let i = 1n; term >= precision; i++) {
-      const bigK = i * Const.ONE;
-      const [c, cneg] = this.subSign(a, bigK - Const.ONE);
-      term = this.mul(term, this.mul(c, x));
-      term = this.div(term, bigK);
-      if (term == 0n) break;
-
-      if (xneg) negative = !negative;
-      if (cneg) negative = !negative;
-      if (negative) {
-        sum = this.sub(sum, term);
-      } else {
-        sum = this.add(sum, term);
-      }
-    }
-
-    return sum;
-  }
-
-  /**
-   * @notice Computes the division of 2 int256 with ONE precision
-   * @dev Converts inputs to uint256 if needed, and then uses div(uint256, uint256)
-   * @param a The int256 representation of a floating point number with ONE precision
-   * @param b The int256 representation of a floating point number with ONE precision
-   * @return b The division of 2 int256 with ONE precision
-   */
-  static divInt256(a: bigint, b: bigint): bigint {
-    if (a < 0) {
-      if (b < 0) {
-        return Num.div(-a, -b); // both negative
-      } else {
-        return -Num.div(-a, b); // a < 0, b >= 0
-      }
-    } else {
-      if (b < 0) {
-        return -Num.div(a, -b); // a >= 0, b < 0
-      } else {
-        return Num.div(a, b); // both positive
-      }
-    }
-
-    // _require(c2 <= BI_MAX_INT, "Err.MATH_OVERFLOW");
-    // _require(c2 >= -BI_MAX_INT, "Err.MATH_UNDERFLOW");
-  }
-
-  static positivePart(value: bigint): bigint {
-    if (value <= 0n) {
-      return 0n;
-    }
-    return value;
-  }
-
-  static max(a: bigint, b: bigint): bigint {
-    if (a > b) {
-      return a;
-    }
-    return b;
-  }
-
-  static min(a: bigint, b: bigint): bigint {
-    if (a < b) {
-      return a;
-    }
-    return b;
-  }
-}

package/src/dex/swaap-v1/libraries/PoolQuotations.ts

@@ -1,322 +0,0 @@
-import { Const } from './Const';
-import { Num } from './Num';
-import { MathMMM } from './MathMMM';
-import * as Struct from './Struct';
-import { ChainlinkUtils } from './ChainlinkUtils';
-import {
-  ChainLinkData,
-  OracleData,
-  TokenData,
-  SwaapV1PoolParameters,
-} from '../types';
-import { DeepReadonly } from 'ts-essentials';
-
-const _require = (b: boolean, message: string) => {
-  if (!b) throw new Error(message);
-};
-
-export class PoolQuotations {
-  /**
-   * @return adjustedTokenWeight
-   */
-  static getTokenLatestInfo(
-    tokenData: TokenData,
-    oracleData: OracleData,
-    currentTimestamp: bigint,
-  ): Struct.TokenGlobal {
-    const latestPrice =
-      oracleData.historicalOracleState[oracleData.latestRoundId].answer;
-    const latestTimestamp =
-      oracleData.historicalOracleState[oracleData.latestRoundId].timestamp;
-
-    const tokenRecord: Struct.TokenRecord = {
-      decimals: BigInt(
-        tokenData.decimals + oracleData.oraclesBindState.decimals,
-      ),
-      balance: tokenData.balance,
-      weight: Num.mul(
-        tokenData.initialWeight,
-        // TODO: BigInt wrapper should be removed after fixing price type
-        Num.div(latestPrice, BigInt(oracleData.oraclesBindState.price)),
-      ),
-    };
-
-    const latestRound: Struct.LatestRound = ChainlinkUtils.getLatestRound(
-      oracleData.latestRoundId,
-      oracleData.historicalOracleState,
-      currentTimestamp,
-    );
-
-    const tokenGlobal: Struct.TokenGlobal = {
-      info: tokenRecord,
-      latestRound: latestRound,
-    };
-
-    return tokenGlobal;
-  }
-
-  /**
-   * @notice Computes the amount of tokenOut received when swapping a fixed amount of tokenIn
-   * @param tokenIn The address of the input token
-   * @param tokenAmountIn The fixed amount of tokenIn to be swapped
-   * @param tokenOut The address of the received token
-   * @param minAmountOut The minimum amount of tokenOut that can be received
-   * @param maxPrice The maximum spot price accepted before the swap
-   * @return swapResult The swap result (amount out, spread and tax base in)
-   * @return priceResult The price result (spot price before & after the swap, latest oracle price in & out)
-   */
-  static getAmountOutGivenInMMM(
-    tokenDataIn: DeepReadonly<TokenData>,
-    oracleDataIn: DeepReadonly<OracleData>,
-    tokenAmountIn: DeepReadonly<bigint>,
-    tokenDataOut: DeepReadonly<TokenData>,
-    oracleDataOut: DeepReadonly<OracleData>,
-    // minAmountOut: DeepReadonly<bigint>,
-    // maxPrice: DeepReadonly<bigint>,
-    poolParameters: DeepReadonly<SwaapV1PoolParameters>,
-    currentTimestamp: DeepReadonly<bigint>,
-  ): bigint {
-    if (tokenAmountIn == 0n) {
-      return 0n;
-    }
-    _require(
-      tokenAmountIn <= Num.mul(tokenDataIn.balance, Const.MAX_IN_RATIO),
-      'Err.MAX_IN_RATIO',
-    );
-
-    let tokenGlobalIn = PoolQuotations.getTokenLatestInfo(
-      tokenDataIn,
-      oracleDataIn,
-      currentTimestamp,
-    );
-    let tokenGlobalOut = PoolQuotations.getTokenLatestInfo(
-      tokenDataOut,
-      oracleDataOut,
-      currentTimestamp,
-    );
-
-    let spotPriceBefore = MathMMM.calcSpotPrice(
-      tokenDataIn.balance,
-      tokenGlobalIn.info.weight,
-      tokenDataOut.balance,
-      tokenGlobalOut.info.weight,
-      poolParameters.swapFee,
-    );
-
-    // _require(spotPriceBefore <= maxPrice, 'Err.BAD_LIMIT_PRICE');
-
-    const swapResult = PoolQuotations.getAmountOutGivenInMMMWithTimestamp(
-      tokenGlobalIn,
-      tokenGlobalOut,
-      tokenAmountIn,
-      currentTimestamp,
-      poolParameters,
-      oracleDataIn.historicalOracleState,
-      oracleDataOut.historicalOracleState,
-    );
-    // _require(swapResult.amount >= minAmountOut, 'Err.LIMIT_OUT');
-    const spotPriceAfter = MathMMM.calcSpotPrice(
-      tokenGlobalIn.info.balance + tokenAmountIn,
-      tokenGlobalIn.info.weight,
-      Num.sub(tokenGlobalOut.info.balance, swapResult.amount),
-      tokenGlobalOut.info.weight,
-      poolParameters.swapFee,
-    );
-
-    _require(spotPriceAfter >= spotPriceBefore, 'Err.MATH_APPROX');
-    const maxAmount = Num.divTruncated(tokenAmountIn, spotPriceBefore);
-    if (swapResult.amount > maxAmount) {
-      swapResult.amount = maxAmount;
-    }
-    _require(
-      Num.div(
-        Num.mul(spotPriceAfter, Const.ONE - poolParameters.swapFee),
-        ChainlinkUtils.getTokenRelativePrice(
-          tokenGlobalIn.latestRound.price,
-          tokenGlobalIn.info.decimals,
-          tokenGlobalOut.latestRound.price,
-          tokenGlobalOut.info.decimals,
-        ),
-      ) <= poolParameters.maxPriceUnpegRatio,
-      'Err.MAX_PRICE_UNPEG_RATIO',
-    );
-
-    // const priceIn = tokenGlobalIn.latestRound.price;
-    // const priceOut = tokenGlobalOut.latestRound.price;
-
-    return swapResult.amount;
-  }
-
-  static getAmountOutGivenInMMMWithTimestamp(
-    tokenGlobalIn: Struct.TokenGlobal,
-    tokenGlobalOut: Struct.TokenGlobal,
-    tokenAmountIn: bigint,
-    currentTimestamp: bigint,
-    poolParameters: SwaapV1PoolParameters,
-    historicalPricesIn: ChainLinkData,
-    historicalPricesOut: ChainLinkData,
-  ): Struct.SwapResult {
-    const swapParameters: Struct.SwapParameters = {
-      amount: tokenAmountIn,
-      fee: poolParameters.swapFee,
-      fallbackSpread: Const.FALLBACK_SPREAD,
-    };
-
-    const gbmParameters: Struct.GBMParameters = {
-      z: poolParameters.dynamicCoverageFeesZ,
-      horizon: poolParameters.dynamicCoverageFeesHorizon,
-    };
-
-    const hpParameters: Struct.HistoricalPricesParameters = {
-      lookbackInRound: poolParameters.priceStatisticsLookbackInRound,
-      lookbackInSec: poolParameters.priceStatisticsLookbackInSec,
-      timestamp: currentTimestamp,
-      lookbackStepInRound: poolParameters.priceStatisticsLookbackStepInRound,
-    };
-
-    return MathMMM.calcOutGivenInMMM(
-      tokenGlobalIn,
-      tokenGlobalOut,
-      ChainlinkUtils.getTokenRelativePrice(
-        tokenGlobalIn.latestRound.price,
-        tokenGlobalIn.info.decimals,
-        tokenGlobalOut.latestRound.price,
-        tokenGlobalOut.info.decimals,
-      ),
-      swapParameters,
-      gbmParameters,
-      hpParameters,
-      historicalPricesIn,
-      historicalPricesOut,
-      currentTimestamp,
-    );
-  }
-
-  static getAmountInGivenOutMMM(
-    tokenDataIn: DeepReadonly<TokenData>,
-    oracleDataIn: DeepReadonly<OracleData>,
-    // maxAmountIn: DeepReadonly<bigint>,
-    tokenDataOut: DeepReadonly<TokenData>,
-    oracleDataOut: DeepReadonly<OracleData>,
-    tokenAmountOut: DeepReadonly<bigint>,
-    // maxPrice: DeepReadonly<bigint>,
-    poolParameters: DeepReadonly<SwaapV1PoolParameters>,
-    currentTimestamp: DeepReadonly<bigint>,
-  ): bigint {
-    if (tokenAmountOut == 0n) {
-      return 0n;
-    }
-    _require(
-      tokenAmountOut <= Num.mul(tokenDataOut.balance, Const.MAX_OUT_RATIO),
-      'Err.MAX_OUT_RATIO',
-    );
-
-    const tokenGlobalIn = PoolQuotations.getTokenLatestInfo(
-      tokenDataIn,
-      oracleDataIn,
-      currentTimestamp,
-    );
-    const tokenGlobalOut = PoolQuotations.getTokenLatestInfo(
-      tokenDataOut,
-      oracleDataOut,
-      currentTimestamp,
-    );
-
-    const spotPriceBefore = MathMMM.calcSpotPrice(
-      tokenGlobalIn.info.balance,
-      tokenGlobalIn.info.weight,
-      tokenGlobalOut.info.balance,
-      tokenGlobalOut.info.weight,
-      poolParameters.swapFee,
-    );
-
-    // _require(spotPriceBefore <= maxPrice, 'Err.BAD_LIMIT_PRICE');
-
-    let swapResult = PoolQuotations.getAmountInGivenOutMMMWithTimestamp(
-      tokenGlobalIn,
-      tokenGlobalOut,
-      tokenAmountOut,
-      currentTimestamp,
-      poolParameters,
-      oracleDataIn.historicalOracleState,
-      oracleDataOut.historicalOracleState,
-    );
-
-    // _require(swapResult.amount <= maxAmountIn, 'Err.LIMIT_IN');
-
-    const spotPriceAfter = MathMMM.calcSpotPrice(
-      tokenGlobalIn.info.balance + swapResult.amount,
-      tokenGlobalIn.info.weight,
-      Num.sub(tokenGlobalOut.info.balance, tokenAmountOut),
-      tokenGlobalOut.info.weight,
-      poolParameters.swapFee,
-    );
-
-    _require(spotPriceAfter >= spotPriceBefore, 'Err.MATH_APPROX');
-    const minAmount = Num.mul(spotPriceBefore, tokenAmountOut) + 1n;
-    if (swapResult.amount < minAmount) {
-      swapResult.amount = minAmount;
-    }
-    _require(
-      Num.div(
-        Num.mul(spotPriceAfter, Const.ONE - poolParameters.swapFee),
-        ChainlinkUtils.getTokenRelativePrice(
-          tokenGlobalIn.latestRound.price,
-          tokenGlobalIn.info.decimals,
-          tokenGlobalOut.latestRound.price,
-          tokenGlobalOut.info.decimals,
-        ),
-      ) <= poolParameters.maxPriceUnpegRatio,
-      'Err.MAX_PRICE_UNPEG_RATIO',
-    );
-
-    return swapResult.amount;
-  }
-
-  static getAmountInGivenOutMMMWithTimestamp(
-    tokenGlobalIn: Struct.TokenGlobal,
-    tokenGlobalOut: Struct.TokenGlobal,
-    tokenAmountOut: bigint,
-    currentTimestamp: bigint,
-    poolParameters: SwaapV1PoolParameters,
-    historicalPricesIn: ChainLinkData,
-    historicalPricesOut: ChainLinkData,
-  ): Struct.SwapResult {
-    const swapParameters: Struct.SwapParameters = {
-      amount: tokenAmountOut,
-      fee: poolParameters.swapFee,
-      fallbackSpread: Const.FALLBACK_SPREAD,
-    };
-
-    const gbmParameters: Struct.GBMParameters = {
-      z: poolParameters.dynamicCoverageFeesZ,
-      horizon: poolParameters.dynamicCoverageFeesHorizon,
-    };
-
-    const hpParameters: Struct.HistoricalPricesParameters = {
-      lookbackInRound: poolParameters.priceStatisticsLookbackInRound,
-      lookbackInSec: poolParameters.priceStatisticsLookbackInSec,
-      timestamp: currentTimestamp,
-      lookbackStepInRound: poolParameters.priceStatisticsLookbackStepInRound,
-    };
-
-    const swapResult = MathMMM.calcInGivenOutMMM(
-      tokenGlobalIn,
-      tokenGlobalOut,
-      ChainlinkUtils.getTokenRelativePrice(
-        tokenGlobalIn.latestRound.price,
-        tokenGlobalIn.info.decimals,
-        tokenGlobalOut.latestRound.price,
-        tokenGlobalOut.info.decimals,
-      ),
-      swapParameters,
-      gbmParameters,
-      hpParameters,
-      historicalPricesIn,
-      historicalPricesOut,
-      currentTimestamp,
-    );
-
-    return swapResult;
-  }
-}

package/src/dex/swaap-v1/libraries/Struct.ts

@@ -1,66 +0,0 @@
-export type TokenGlobal = {
-  info: TokenRecord;
-  latestRound: LatestRound;
-};
-
-export type LatestRound = {
-  roundId: number;
-  price: bigint;
-  timestamp: bigint;
-};
-
-export type HistoricalPricesParameters = {
-  lookbackInRound: number;
-  lookbackInSec: bigint;
-  timestamp: bigint;
-  lookbackStepInRound: number;
-};
-
-export type HistoricalPricesData = {
-  startIndex: number;
-  timestamps: bigint[];
-  prices: bigint[];
-};
-
-export type SwapResult = {
-  amount: bigint;
-  spread: bigint;
-  taxBaseIn: bigint;
-};
-
-export type PriceResult = {
-  spotPriceBefore: bigint;
-  spotPriceAfter: bigint;
-  priceIn: bigint;
-  priceOut: bigint;
-};
-
-export type GBMEstimation = {
-  mean: bigint;
-  variance: bigint;
-  success: boolean;
-};
-
-export type TokenRecord = {
-  decimals: bigint; // token decimals + oracle decimals
-  balance: bigint;
-  weight: bigint;
-};
-
-export type SwapParameters = {
-  amount: bigint;
-  fee: bigint;
-  fallbackSpread: bigint;
-};
-
-export type JoinExitSwapParameters = {
-  amount: bigint;
-  fee: bigint;
-  fallbackSpread: bigint;
-  poolSupply: bigint;
-};
-
-export type GBMParameters = {
-  z: bigint;
-  horizon: bigint;
-};

package/src/dex/swaap-v1/swaap-v1-e2e.test.ts

@@ -1,75 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders } from '../../../tests/constants-e2e';
-import { Network, ContractMethod, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-import { generateConfig } from '../../config';
-
-describe('SwaapV1 E2E', () => {
-  const dexKey = 'SwaapV1';
-
-  describe('SwaapV1 POLYGON_V6', () => {
-    const network = Network.POLYGON;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-
-    const tokenASymbol: string = 'WETH';
-    const tokenBSymbol: string = 'USDC';
-
-    const tokenAAmount: string = '1000000000000000';
-    const tokenBAmount: string = '1000000';
-
-    const sideToContractMethods = new Map([
-      [
-        SwapSide.SELL,
-        [
-          ContractMethod.swapExactAmountIn,
-          // ContractMethod.simpleSwap,
-          // ContractMethod.multiSwap,
-          // ContractMethod.megaSwap,
-        ],
-      ],
-      // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-      [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
-    ]);
-
-    sideToContractMethods.forEach((contractMethods, side) =>
-      contractMethods.forEach((contractMethod: ContractMethod) => {
-        describe(`${contractMethod}`, () => {
-          it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
-            await testE2E(
-              tokens[tokenASymbol],
-              tokens[tokenBSymbol],
-              holders[tokenASymbol],
-              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
-            await testE2E(
-              tokens[tokenBSymbol],
-              tokens[tokenASymbol],
-              holders[tokenBSymbol],
-              side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-        });
-      }),
-    );
-  });
-});