@paraswap/dex-lib 4.1.20 → 4.1.21

package/src/dex/maverick-v2/maverick-math/maverick-basic-math.ts

@@ -1,152 +0,0 @@
-import { BI_MAX_UINT256, BI_POWS } from '../../../bigint-constants';
-import { _require } from '../../../utils';
-
-export class MaverickBasicMath {
-  static MAX_POW_RELATIVE_ERROR = BI_POWS[4];
-
-  static abs(x: bigint) {
-    return x < 0n ? -x : x;
-  }
-
-  static min(a: bigint, b: bigint): bigint {
-    return a < b ? a : b;
-  }
-
-  static max(a: bigint, b: bigint): bigint {
-    return a >= b ? a : b;
-  }
-
-  static clip(x: bigint, y: bigint): bigint {
-    return x < y ? 0n : x - y;
-  }
-
-  static mulDivFloor(x: bigint, y: bigint, k: bigint): bigint {
-    return this.mulDiv(x, y, this.max(1n, k));
-  }
-
-  static mulmod(x: bigint, y: bigint, k: bigint): bigint {
-    return (x * y) % k;
-  }
-
-  static mulFloor(x: bigint, y: bigint): bigint {
-    return this.mulDiv(x, y, BI_POWS[18]);
-  }
-
-  static mulDivCeil(x: bigint, y: bigint, k: bigint): bigint {
-    let result = this.mulDivFloor(x, y, k);
-    if (this.mulmod(x, y, this.max(1n, k)) != 0n) result = result + 1n;
-    return result;
-  }
-
-  static sqrt(x: bigint) {
-    let y = x;
-
-    let z = 181n;
-
-    if (y >= 0x10000000000000000000000000000000000) {
-      y >>= 128n;
-      z <<= 64n;
-    }
-
-    if (y >= 0x1000000000000000000) {
-      y >>= 64n;
-      z <<= 32n;
-    }
-
-    if (y >= 0x10000000000) {
-      y >>= 32n;
-      z <<= 16n;
-    }
-
-    if (y >= 0x1000000) {
-      y >>= 16n;
-      z <<= 8n;
-    }
-
-    z = (z * (y + 65536n)) >> 18n;
-    z = (x / z + z) >> 1n;
-    z = (x / z + z) >> 1n;
-    z = (x / z + z) >> 1n;
-    z = (x / z + z) >> 1n;
-    z = (x / z + z) >> 1n;
-    z = (x / z + z) >> 1n;
-    z = (x / z + z) >> 1n;
-
-    return x / z < z ? z - 1n : z;
-  }
-
-  static divDown(x: bigint, y: bigint): bigint {
-    return this.mulDivDown(x, BI_POWS[18], y);
-  }
-
-  static divUp(x: bigint, y: bigint): bigint {
-    return this.mulDivUp(x, BI_POWS[18], y);
-  }
-
-  static mulUp(x: bigint, y: bigint): bigint {
-    return this.mulDivUp(x, y, BI_POWS[18]);
-  }
-
-  static mulDown(x: bigint, y: bigint): bigint {
-    return this.mulDivDown(x, y, BI_POWS[18]);
-  }
-
-  static invFloor(x: bigint): bigint {
-    return BI_POWS[36] / x;
-  }
-
-  static invCeil(denominator: bigint): bigint {
-    return (BI_POWS[36] - 1n) / denominator + 1n;
-  }
-
-  static mulDivDown(x: bigint, y: bigint, denominator: bigint): bigint {
-    let z = x * y;
-
-    if (denominator === 0n) {
-      denominator = 1n;
-    }
-
-    if (denominator === 0n && !(y === 0n || x <= BI_MAX_UINT256 / y)) {
-      throw new Error('MATH: MUL_DIV_DOWN_OVERFLOW');
-    }
-
-    return z / denominator;
-  }
-
-  static mulDiv(x: bigint, y: bigint, denominator: bigint): bigint {
-    const result = (x * y) / denominator;
-
-    _require(
-      result <= BI_MAX_UINT256,
-      '',
-      { result, BI_MAX_UINT: BI_MAX_UINT256 },
-      'result <= BI_MAX_UINT256',
-    );
-
-    return result;
-  }
-
-  static divCeil(x: bigint, y: bigint): bigint {
-    return this.mulDivCeil(x, BI_POWS[18], y);
-  }
-
-  static mulCeil(x: bigint, y: bigint): bigint {
-    return this.mulDivCeil(x, y, BI_POWS[18]);
-  }
-
-  static mulDivUp(x: bigint, y: bigint, denominator: bigint): bigint {
-    let z = x * y;
-
-    if (z === 0n) {
-      return 0n;
-    }
-
-    return (z - 1n) / denominator + 1n;
-  }
-
-  static floorD8Unchecked(val: bigint): bigint {
-    let val32 = val / BI_POWS[8];
-    let check = val < 0 && val % BI_POWS[8] != 0n;
-    return check ? val32 - 1n : val32;
-  }
-}

package/src/dex/maverick-v2/maverick-math/maverick-bin-math.ts

@@ -1,288 +0,0 @@
-import { BI_POWS } from '../../../bigint-constants';
-import { AddLiquidityInfo, Bin, BinDelta, Tick } from '../types';
-import { MaverickBasicMath } from './maverick-basic-math';
-import { MaverickPoolLib } from './maverick-pool-lib';
-import { MaverickTickMath } from './maverick-tick-math';
-
-const MINIMUM_LIQUIDITY = BI_POWS[8];
-
-export class MaverickBinMath {
-  static lpBalancesFromDeltaReserve(
-    self: Bin,
-    tick: Tick,
-    deltaA: bigint,
-    deltaB: bigint,
-  ): bigint {
-    if (tick.reserveA >= tick.reserveB) {
-      let reserveA = MaverickBasicMath.mulDivUp(
-        tick.reserveA,
-        self.tickBalance,
-        tick.totalSupply,
-      );
-      return MaverickBasicMath.mulDivDown(
-        deltaA,
-        MaverickBasicMath.max(1n, self.totalSupply),
-        reserveA,
-      );
-    } else {
-      let reserveB = MaverickBasicMath.mulDivUp(
-        tick.reserveB,
-        self.tickBalance,
-        tick.totalSupply,
-      );
-      return MaverickBasicMath.mulDivDown(
-        deltaB,
-        MaverickBasicMath.max(1n, self.totalSupply),
-        reserveB,
-      );
-    }
-  }
-
-  static addLiquidity(
-    self: Bin,
-    tick: Tick,
-    deltaLpBalance: bigint,
-    addLiquidityInfo: AddLiquidityInfo,
-  ) {
-    let deltaTickBalance = this.deltaTickBalanceFromDeltaLpBalance(
-      self.tickBalance,
-      self.totalSupply,
-      tick,
-      deltaLpBalance,
-      addLiquidityInfo,
-    );
-
-    this.updateBinState(
-      self,
-      tick,
-      addLiquidityInfo.deltaA,
-      addLiquidityInfo.deltaB,
-      deltaLpBalance,
-      deltaTickBalance,
-    );
-  }
-
-  static setRequiredDeltaReservesForEmptyTick(
-    deltaLpBalance: bigint,
-    addLiquidityInfo: AddLiquidityInfo,
-  ) {
-    let [sqrtLowerTickPrice, sqrtUpperTickPrice] =
-      MaverickTickMath.tickSqrtPrices(
-        addLiquidityInfo.tickSpacing,
-        addLiquidityInfo.tick,
-      );
-    addLiquidityInfo.deltaA = addLiquidityInfo.tickLtActive
-      ? MaverickBasicMath.mulCeil(deltaLpBalance, sqrtLowerTickPrice)
-      : 0n;
-    addLiquidityInfo.deltaB = addLiquidityInfo.tickLtActive
-      ? 0n
-      : MaverickBasicMath.divCeil(deltaLpBalance, sqrtUpperTickPrice);
-  }
-
-  static deltaTickBalanceFromDeltaLpBalance(
-    binTickBalance: bigint,
-    binTotalSupply: bigint,
-    tick: Tick,
-    deltaLpBalance: bigint,
-    addLiquidityInfo: AddLiquidityInfo,
-  ): bigint {
-    let numerator = MaverickBasicMath.max(1n, binTickBalance) * deltaLpBalance;
-    let denominator =
-      MaverickBasicMath.max(1n, tick.totalSupply) *
-      MaverickBasicMath.max(1n, binTotalSupply);
-    if (tick.reserveA != 0n || tick.reserveB != 0n) {
-      addLiquidityInfo.deltaA = MaverickBasicMath.mulDivCeil(
-        tick.reserveA,
-        numerator,
-        denominator,
-      );
-      addLiquidityInfo.deltaB = MaverickBasicMath.mulDivCeil(
-        tick.reserveB,
-        numerator,
-        denominator,
-      );
-    } else {
-      this.setRequiredDeltaReservesForEmptyTick(
-        deltaLpBalance,
-        addLiquidityInfo,
-      );
-    }
-
-    return tick.totalSupply === 0n
-      ? deltaLpBalance
-      : MaverickBasicMath.mulDivDown(
-          deltaLpBalance,
-          MaverickBasicMath.max(1n, binTickBalance),
-          binTotalSupply,
-        );
-  }
-
-  static addLiquidityByReserves(
-    self: Bin,
-    tick: Tick,
-    deltaA: bigint,
-    deltaB: bigint,
-    deltaLpBalance: bigint,
-  ) {
-    let deltaTickBalance = MaverickBasicMath.mulDivDown(
-      deltaLpBalance,
-      MaverickBasicMath.max(1n, self.tickBalance),
-      self.totalSupply,
-    );
-
-    this.updateBinState(
-      self,
-      tick,
-      deltaA,
-      deltaB,
-      deltaLpBalance,
-      deltaTickBalance,
-    );
-  }
-
-  static updateBinState(
-    self: Bin,
-    tick: Tick,
-    deltaA: bigint,
-    deltaB: bigint,
-    deltaLpBalance: bigint,
-    deltaTickBalance: bigint,
-  ) {
-    let totalSupply = self.totalSupply;
-    if (totalSupply === 0n) {
-      if (deltaLpBalance < MINIMUM_LIQUIDITY) {
-        throw 'insufficient liquidity';
-      }
-      totalSupply = MINIMUM_LIQUIDITY;
-    }
-
-    self.totalSupply = totalSupply + deltaLpBalance;
-    tick.totalSupply = tick.totalSupply + deltaTickBalance;
-
-    self.tickBalance = self.tickBalance + deltaTickBalance;
-
-    tick.reserveA = tick.reserveA + deltaA;
-    tick.reserveB = tick.reserveB + deltaB;
-  }
-
-  static removeLiquidity(
-    self: Bin,
-    ticks: { [id: string]: Tick },
-    bins: { [id: string]: Bin },
-    deltaLpAmount: bigint,
-  ): [bigint, bigint] {
-    let activeBin = self;
-
-    let activeBinDeltaLpBalance = deltaLpAmount;
-    if (self.mergeId != 0n) {
-      activeBin = bins[self.mergeId.toString()];
-
-      if (activeBin.mergeId != 0n) {
-        throw 'migrate first';
-      }
-
-      let tempTotalSupply = self.totalSupply;
-      self.totalSupply = MaverickBasicMath.clip(
-        self.totalSupply,
-        deltaLpAmount,
-      );
-
-      activeBinDeltaLpBalance = MaverickBasicMath.min(
-        self.mergeBinBalance,
-        MaverickBasicMath.mulDivDown(
-          activeBinDeltaLpBalance,
-          self.mergeBinBalance,
-          tempTotalSupply,
-        ),
-      );
-
-      self.mergeBinBalance -= activeBinDeltaLpBalance;
-    }
-
-    let binDelta: BinDelta = {
-      deltaA: 0n,
-      deltaB: 0n,
-    };
-
-    let tick: Tick = ticks[activeBin.tick.toString()];
-
-    activeBinDeltaLpBalance = MaverickBasicMath.min(
-      activeBinDeltaLpBalance,
-      activeBin.totalSupply,
-    );
-
-    let deltaTickBalance = MaverickBasicMath.mulDivDown(
-      activeBinDeltaLpBalance,
-      activeBin.tickBalance,
-      activeBin.totalSupply,
-    );
-
-    deltaTickBalance = MaverickBasicMath.min(
-      deltaTickBalance,
-      tick.totalSupply,
-    );
-
-    [binDelta.deltaA, binDelta.deltaB] = MaverickPoolLib.binReservesCalc(
-      deltaTickBalance,
-      tick.reserveA,
-      tick.reserveB,
-      tick.totalSupply,
-    );
-
-    tick.reserveA = MaverickBasicMath.clip(tick.reserveA, binDelta.deltaA);
-    tick.reserveB = MaverickBasicMath.clip(tick.reserveB, binDelta.deltaB);
-
-    activeBin.tickBalance = MaverickBasicMath.clip(
-      activeBin.tickBalance,
-      deltaTickBalance,
-    );
-    tick.totalSupply = MaverickBasicMath.clip(
-      tick.totalSupply,
-      deltaTickBalance,
-    );
-    activeBin.totalSupply = MaverickBasicMath.clip(
-      activeBin.totalSupply,
-      activeBinDeltaLpBalance,
-    );
-
-    return [binDelta.deltaA, binDelta.deltaB];
-  }
-
-  static migrateBinsUpStack(
-    self: Bin,
-    bins: { [id: string]: Bin },
-    maxRecursion: bigint,
-  ): void {
-    if (self.mergeId === 0n) return;
-
-    let nextBin = bins[self.mergeId.toString()];
-
-    if (nextBin.mergeId === 0n) return;
-
-    self.mergeId = nextBin.mergeId;
-
-    let tempTotalSupply = nextBin.totalSupply;
-    let tempMergeBinBalance = self.mergeBinBalance;
-
-    nextBin.totalSupply = MaverickBasicMath.clip(
-      nextBin.totalSupply,
-      self.mergeBinBalance,
-    );
-
-    self.mergeBinBalance = MaverickBasicMath.mulDiv(
-      tempMergeBinBalance,
-      nextBin.mergeBinBalance,
-      tempTotalSupply,
-    );
-
-    nextBin.mergeBinBalance = MaverickBasicMath.clip(
-      nextBin.mergeBinBalance,
-      self.mergeBinBalance,
-    );
-
-    maxRecursion -= 1n;
-    if (maxRecursion != 0n) {
-      return this.migrateBinsUpStack(self, bins, maxRecursion);
-    }
-  }
-}

package/src/dex/maverick-v2/maverick-math/maverick-delta-math.ts

@@ -1,32 +0,0 @@
-export type Delta = {
-  deltaInBinInternal: bigint;
-  deltaInErc: bigint;
-  deltaOutErc: bigint;
-  excess: bigint;
-  tokenAIn: boolean;
-  exactOutput: boolean;
-  swappedToMaxPrice: boolean;
-  skipCombine: boolean;
-  tickLimit: bigint;
-  sqrtLowerTickPrice: bigint;
-  sqrtUpperTickPrice: bigint;
-  sqrtPrice: bigint;
-  fractionalPart: bigint;
-};
-
-export class MaverickDeltaMath {
-  static pastMaxTick(self: Delta, activeTick: bigint) {
-    self.swappedToMaxPrice = self.tokenAIn
-      ? self.tickLimit < activeTick
-      : self.tickLimit > activeTick;
-    if (self.swappedToMaxPrice) {
-      self.excess = 0n;
-      self.skipCombine = true;
-    }
-    return self.swappedToMaxPrice;
-  }
-
-  static sqrtEdgePrice(self: Delta) {
-    return self.tokenAIn ? self.sqrtUpperTickPrice : self.sqrtLowerTickPrice;
-  }
-}

package/src/dex/maverick-v2/maverick-math/maverick-math.ts

@@ -1,30 +0,0 @@
-export class MaverickMath {
-  static ammScaleToTokenScale(
-    amount: bigint,
-    scaleFactor: bigint,
-    ceil: boolean,
-  ): bigint {
-    if (scaleFactor === 1n || amount === 0n) {
-      return amount;
-    } else {
-      if (!ceil) return amount / scaleFactor;
-      return (amount - 1n) / scaleFactor + 1n;
-    }
-  }
-
-  static tokenScaleToAmmScale(amount: bigint, scaleFactor: bigint): bigint {
-    if (scaleFactor === 1n) {
-      return amount;
-    } else {
-      return amount * scaleFactor;
-    }
-  }
-
-  static scale(decimals: bigint): bigint {
-    if (decimals === 18n) {
-      return 1n;
-    } else {
-      return 10n ** (18n - decimals);
-    }
-  }
-}

package/src/dex/maverick-v2/maverick-math/maverick-pool-lib.ts

@@ -1,42 +0,0 @@
-import { Bin, Tick } from '../types';
-import { MaverickBasicMath } from './maverick-basic-math';
-
-export class MaverickPoolLib {
-  static binReserves(bin: Bin, tick: Tick): [bigint, bigint] {
-    return this.binReservesCalc(
-      bin.tickBalance,
-      tick.reserveA,
-      tick.reserveB,
-      tick.totalSupply,
-    );
-  }
-
-  static binReservesCalc(
-    tickBalance: bigint,
-    tickReserveA: bigint,
-    tickReserveB: bigint,
-    tickTotalSupply: bigint,
-  ): [bigint, bigint] {
-    let reserveA = 0n;
-    let reserveB = 0n;
-
-    if (tickTotalSupply != 0n) {
-      reserveA = this.reserveValue(tickReserveA, tickBalance, tickTotalSupply);
-      reserveB = this.reserveValue(tickReserveB, tickBalance, tickTotalSupply);
-    }
-    return [reserveA, reserveB];
-  }
-
-  static reserveValue(
-    tickReserve: bigint,
-    tickBalance: bigint,
-    tickTotalSupply: bigint,
-  ): bigint {
-    let reserve = MaverickBasicMath.mulDivFloor(
-      tickReserve,
-      tickBalance,
-      tickTotalSupply,
-    );
-    return MaverickBasicMath.min(tickReserve, reserve);
-  }
-}