@paraswap/dex-lib 3.6.2 → 3.6.3

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

@@ -0,0 +1,199 @@
+import { BI_POWS } from '../../../bigint-constants';
+import { _require } from '../../../utils';
+import { TickData } from '../types';
+import { Delta } from './maverick-delta-math';
+import { MaverickBasicMath } from './maverick-basic-math';
+
+export class MaverickSwapMath {
+  static amountToBinNetOfProtocolFee(
+    deltaInErc: bigint,
+    feeBasis: bigint,
+    protocolFeeD3: bigint,
+  ): bigint {
+    return protocolFeeD3 != 0n
+      ? MaverickBasicMath.clip(
+          deltaInErc,
+          MaverickBasicMath.mulDivUp(feeBasis, protocolFeeD3, BI_POWS[3]),
+        )
+      : deltaInErc;
+  }
+
+  static remainingBinInputSpaceGivenOutput(
+    binLiquidity: bigint,
+    output: bigint,
+    sqrtPrice: bigint,
+    tokenAIn: boolean,
+  ): bigint {
+    let outOverL =
+      binLiquidity === 0n ? 0n : MaverickBasicMath.divUp(output, binLiquidity);
+
+    if (tokenAIn) {
+      return MaverickBasicMath.mulDivUp(
+        output,
+        sqrtPrice,
+        MaverickBasicMath.invFloor(sqrtPrice) - outOverL,
+      );
+    } else {
+      return MaverickBasicMath.divUp(
+        output,
+        MaverickBasicMath.mulDown(sqrtPrice, sqrtPrice - outOverL),
+      );
+    }
+  }
+
+  static computeSwapExactIn(
+    sqrtPrice: bigint,
+    tickData: TickData,
+    amountIn: bigint,
+    tokenAIn: boolean,
+    fee: bigint,
+    protocolFeeD3: bigint,
+  ): Delta {
+    let delta: Delta = {
+      deltaInBinInternal: 0n,
+      deltaInErc: 0n,
+      deltaOutErc: 0n,
+      excess: 0n,
+      tokenAIn: tokenAIn,
+      exactOutput: false,
+      swappedToMaxPrice: false,
+      skipCombine: false,
+      tickLimit: 0n,
+      sqrtLowerTickPrice: 0n,
+      sqrtUpperTickPrice: 0n,
+      sqrtPrice: 0n,
+      fractionalPart: 0n,
+    };
+
+    delta.deltaOutErc = tokenAIn
+      ? tickData.currentReserveB
+      : tickData.currentReserveA;
+
+    let binAmountIn = this.remainingBinInputSpaceGivenOutput(
+      tickData.currentLiquidity,
+      delta.deltaOutErc,
+      sqrtPrice,
+      tokenAIn,
+    );
+
+    let feeBasis;
+    let userBinAmountIn = MaverickBasicMath.mulDown(
+      amountIn,
+      BI_POWS[18] - fee,
+    );
+
+    if (userBinAmountIn < binAmountIn) {
+      binAmountIn = userBinAmountIn;
+      delta.deltaInErc = amountIn;
+      feeBasis = delta.deltaInErc - userBinAmountIn;
+    } else {
+      feeBasis = MaverickBasicMath.mulDivUp(
+        binAmountIn,
+        fee,
+        BI_POWS[18] - fee,
+      );
+      delta.deltaInErc = binAmountIn + feeBasis;
+      delta.excess = MaverickBasicMath.clip(amountIn, delta.deltaInErc);
+    }
+
+    delta.deltaInBinInternal = this.amountToBinNetOfProtocolFee(
+      delta.deltaInErc,
+      feeBasis,
+      protocolFeeD3,
+    );
+
+    if (delta.excess != 0n) return delta;
+
+    let inOverL = MaverickBasicMath.divUp(
+      binAmountIn,
+      tickData.currentLiquidity + 1n,
+    );
+
+    delta.deltaOutErc = MaverickBasicMath.min(
+      delta.deltaOutErc,
+      MaverickBasicMath.mulDivDown(
+        binAmountIn,
+        tokenAIn ? MaverickBasicMath.invFloor(sqrtPrice) : sqrtPrice,
+        inOverL + (tokenAIn ? sqrtPrice : MaverickBasicMath.invCeil(sqrtPrice)),
+      ),
+    );
+
+    return delta;
+  }
+
+  static computeSwapExactOut(
+    sqrtPrice: bigint,
+    tickData: TickData,
+    amountOut: bigint,
+    tokenAIn: boolean,
+    fee: bigint,
+    protocolFeeD3: bigint,
+  ): Delta {
+    let delta: Delta = {
+      deltaInBinInternal: 0n,
+      deltaInErc: 0n,
+      deltaOutErc: 0n,
+      excess: 0n,
+      tokenAIn: false,
+      exactOutput: false,
+      swappedToMaxPrice: false,
+      skipCombine: false,
+      tickLimit: 0n,
+      sqrtLowerTickPrice: 0n,
+      sqrtUpperTickPrice: 0n,
+      sqrtPrice: 0n,
+      fractionalPart: 0n,
+    };
+
+    let amountOutAvailable = tokenAIn
+      ? tickData.currentReserveB
+      : tickData.currentReserveA;
+    let swapped = amountOutAvailable <= amountOut;
+    delta.deltaOutErc = swapped ? amountOutAvailable : amountOut;
+    let binAmountIn = this.remainingBinInputSpaceGivenOutput(
+      tickData.currentLiquidity,
+      delta.deltaOutErc,
+      sqrtPrice,
+      tokenAIn,
+    );
+
+    let feeBasis = MaverickBasicMath.mulDivUp(
+      binAmountIn,
+      fee,
+      BI_POWS[18] - fee,
+    );
+    delta.deltaInErc = binAmountIn + feeBasis;
+    delta.deltaInBinInternal = this.amountToBinNetOfProtocolFee(
+      delta.deltaInErc,
+      feeBasis,
+      protocolFeeD3,
+    );
+    delta.excess = swapped
+      ? MaverickBasicMath.clip(amountOut, delta.deltaOutErc)
+      : 0n;
+
+    return delta;
+  }
+
+  static computeEndPrice(delta: Delta, newDelta: Delta, tickData: TickData) {
+    let endSqrtPrice =
+      MaverickBasicMath.divDown(
+        newDelta.deltaInBinInternal,
+        tickData.currentLiquidity,
+      ) +
+      (delta.tokenAIn
+        ? delta.sqrtPrice
+        : MaverickBasicMath.invFloor(delta.sqrtPrice));
+    if (!delta.tokenAIn) {
+      endSqrtPrice = MaverickBasicMath.invFloor(endSqrtPrice);
+    }
+
+    newDelta.fractionalPart = MaverickBasicMath.min(
+      BI_POWS[8],
+      MaverickBasicMath.divDown(
+        MaverickBasicMath.clip(endSqrtPrice, delta.sqrtLowerTickPrice),
+        BI_POWS[10] * (delta.sqrtUpperTickPrice - delta.sqrtLowerTickPrice),
+      ),
+    );
+  }
+}

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

@@ -0,0 +1,171 @@
+import { BI_MAX_UINT256, BI_POWS } from '../../../bigint-constants';
+import { _require } from '../../../utils';
+import { MaverickBasicMath } from './maverick-basic-math';
+
+const MAX_TICK = 460540;
+
+export class MaverickTickMath {
+  static getTickSqrtPriceAndL(
+    reserveA: bigint,
+    reserveB: bigint,
+    sqrtLowerTickPrice: bigint,
+    sqrtUpperTickPrice: bigint,
+  ): [bigint, bigint] {
+    let liquidity = this.getTickL(
+      reserveA,
+      reserveB,
+      sqrtLowerTickPrice,
+      sqrtUpperTickPrice,
+    );
+
+    let sqrtPrice = this.getSqrtPrice(
+      reserveA,
+      reserveB,
+      sqrtLowerTickPrice,
+      sqrtUpperTickPrice,
+      liquidity,
+    );
+
+    return [sqrtPrice, liquidity];
+  }
+
+  static getSqrtPrice(
+    reserveA: bigint,
+    reserveB: bigint,
+    sqrtLowerTickPrice: bigint,
+    sqrtUpperTickPrice: bigint,
+    liquidity: bigint,
+  ): bigint {
+    if (reserveA === 0n) {
+      return sqrtLowerTickPrice;
+    }
+    if (reserveB === 0n) {
+      return sqrtUpperTickPrice;
+    }
+
+    let sqrtPrice = MaverickBasicMath.sqrt(
+      BI_POWS[18] *
+        MaverickBasicMath.divDown(
+          reserveA + MaverickBasicMath.mulDown(liquidity, sqrtLowerTickPrice),
+          reserveB + MaverickBasicMath.divDown(liquidity, sqrtUpperTickPrice),
+        ),
+    );
+
+    return MaverickBasicMath.min(
+      MaverickBasicMath.max(sqrtPrice, sqrtLowerTickPrice),
+      sqrtUpperTickPrice,
+    );
+  }
+
+  static getTickL(
+    reserveA: bigint,
+    reserveB: bigint,
+    sqrtLowerTickPrice: bigint,
+    sqrtUpperTickPrice: bigint,
+  ): bigint {
+    let precisionBump = 0n;
+
+    if (reserveA >> 78n === 0n && reserveB >> 78n === 0n) {
+      precisionBump = 57n;
+      reserveA <<= precisionBump;
+      reserveB <<= precisionBump;
+    }
+
+    let diff;
+    let b =
+      MaverickBasicMath.divDown(reserveA, sqrtUpperTickPrice) +
+      MaverickBasicMath.mulDown(reserveB, sqrtLowerTickPrice);
+    diff = sqrtUpperTickPrice - sqrtLowerTickPrice;
+
+    if (reserveA === 0n || reserveB === 0n)
+      return (
+        MaverickBasicMath.mulDivDown(b, sqrtUpperTickPrice, diff) >>
+        precisionBump
+      );
+
+    b >>= 1n;
+
+    return (
+      MaverickBasicMath.mulDiv(
+        b +
+          MaverickBasicMath.sqrt(
+            MaverickBasicMath.mulDiv(b, b, BI_POWS[18]) +
+              MaverickBasicMath.mulDiv(
+                MaverickBasicMath.mulFloor(reserveB, reserveA),
+                diff,
+                sqrtUpperTickPrice,
+              ),
+          ) *
+            BI_POWS[9],
+        sqrtUpperTickPrice,
+        diff,
+      ) >> precisionBump
+    );
+  }
+
+  static tickSqrtPrices(tickSpacing: bigint, tick: bigint): [bigint, bigint] {
+    return [
+      this.tickSqrtPrice(tickSpacing, tick),
+      this.tickSqrtPrice(tickSpacing, tick + 1n),
+    ];
+  }
+
+  static subTickIndex(tickSpacing: bigint, tick: bigint): bigint {
+    let subTick = MaverickBasicMath.abs(tick);
+    subTick *= tickSpacing;
+    if (subTick > MAX_TICK) {
+      throw new Error('OB');
+    }
+    return subTick;
+  }
+
+  static tickSqrtPrice(tickSpacing: bigint, _tick: bigint): bigint {
+    let tick = this.subTickIndex(tickSpacing, _tick);
+
+    let ratio: bigint =
+      (tick & 0x1n) != 0n
+        ? 0xfffcb933bd6fad9d3af5f0b9f25db4d6n
+        : 0x100000000000000000000000000000000n;
+    if ((tick & 0x2n) != 0n)
+      ratio = (ratio * 0xfff97272373d41fd789c8cb37ffcaa1cn) >> 128n;
+    if ((tick & 0x4n) != 0n)
+      ratio = (ratio * 0xfff2e50f5f656ac9229c67059486f389n) >> 128n;
+    if ((tick & 0x8n) != 0n)
+      ratio = (ratio * 0xffe5caca7e10e81259b3cddc7a064941n) >> 128n;
+    if ((tick & 0x10n) != 0n)
+      ratio = (ratio * 0xffcb9843d60f67b19e8887e0bd251eb7n) >> 128n;
+    if ((tick & 0x20n) != 0n)
+      ratio = (ratio * 0xff973b41fa98cd2e57b660be99eb2c4an) >> 128n;
+    if ((tick & 0x40n) != 0n)
+      ratio = (ratio * 0xff2ea16466c9838804e327cb417cafcbn) >> 128n;
+    if ((tick & 0x80n) != 0n)
+      ratio = (ratio * 0xfe5dee046a99d51e2cc356c2f617dbe0n) >> 128n;
+    if ((tick & 0x100n) != 0n)
+      ratio = (ratio * 0xfcbe86c7900aecf64236ab31f1f9dcb5n) >> 128n;
+    if ((tick & 0x200n) != 0n)
+      ratio = (ratio * 0xf987a7253ac4d9194200696907cf2e37n) >> 128n;
+    if ((tick & 0x400n) != 0n)
+      ratio = (ratio * 0xf3392b0822b88206f8abe8a3b44dd9ben) >> 128n;
+    if ((tick & 0x800n) != 0n)
+      ratio = (ratio * 0xe7159475a2c578ef4f1d17b2b235d480n) >> 128n;
+    if ((tick & 0x1000n) != 0n)
+      ratio = (ratio * 0xd097f3bdfd254ee83bdd3f248e7e785en) >> 128n;
+    if ((tick & 0x2000n) != 0n)
+      ratio = (ratio * 0xa9f746462d8f7dd10e744d913d033333n) >> 128n;
+    if ((tick & 0x4000n) != 0n)
+      ratio = (ratio * 0x70d869a156ddd32a39e257bc3f50aa9bn) >> 128n;
+    if ((tick & 0x8000n) != 0n)
+      ratio = (ratio * 0x31be135f97da6e09a19dc367e3b6da40n) >> 128n;
+    if ((tick & 0x10000n) != 0n)
+      ratio = (ratio * 0x9aa508b5b7e5a9780b0cc4e25d61a56n) >> 128n;
+    if ((tick & 0x20000n) != 0n)
+      ratio = (ratio * 0x5d6af8dedbcb3a6ccb7ce618d14225n) >> 128n;
+    if ((tick & 0x40000n) != 0n)
+      ratio = (ratio * 0x2216e584f630389b2052b8db590en) >> 128n;
+    if ((tick & 0x80000n) != 0n)
+      ratio = (ratio * 0x48a1703920644d4030024fen) >> 128n;
+    if ((tick & 0x100000n) != 0n) ratio = (ratio * 0x149b34ee7b4532n) >> 128n;
+    if (_tick > 0) ratio = BI_MAX_UINT256 / ratio;
+    return (ratio * BI_POWS[18]) >> 128n;
+  }
+}

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

@@ -0,0 +1,54 @@
+import { BI_POWS } from '../../../bigint-constants';
+import { _require } from '../../../utils';
+import { PoolState } from '../types';
+import { MaverickBasicMath } from './maverick-basic-math';
+
+export class TwaMath {
+  static updateValue(
+    self: PoolState,
+    value: bigint,
+    lookback: bigint,
+    timestamp: bigint,
+  ) {
+    if (timestamp === self.lastTimestamp) return;
+    self.lastTwaD8 = this.getTwa(self, lookback, timestamp);
+    self.lastTimestamp = timestamp;
+    self.lastLogPriceD8 = value;
+  }
+
+  static floor(self: PoolState) {
+    return MaverickBasicMath.floorD8Unchecked(self.lastTwaD8);
+  }
+
+  static getTwa(self: PoolState, lookback: bigint, timestamp: bigint): bigint {
+    let timeDiff = timestamp - self.lastTimestamp;
+    timeDiff = MaverickBasicMath.min(lookback, timeDiff);
+    if (timeDiff === 0n) return self.lastTwaD8;
+
+    let absValueDeviation = MaverickBasicMath.min(
+      BI_POWS[8],
+      MaverickBasicMath.abs(self.lastLogPriceD8 - self.lastTwaD8),
+    );
+
+    if (absValueDeviation === 0n) return self.lastTwaD8;
+    let twaDeviation = MaverickBasicMath.mulDivDown(
+      absValueDeviation,
+      timeDiff,
+      lookback,
+    );
+
+    return self.lastTwaD8 > self.lastLogPriceD8
+      ? -twaDeviation + self.lastTwaD8
+      : twaDeviation + self.lastTwaD8;
+  }
+
+  static getTwaFloor(
+    self: PoolState,
+    lookback: bigint,
+    timestamp: bigint,
+  ): bigint {
+    return MaverickBasicMath.floorD8Unchecked(
+      this.getTwa(self, lookback, timestamp),
+    );
+  }
+}

package/src/dex/maverick-v2/maverick-v2-e2e.test.ts

@@ -0,0 +1,193 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+import { ContractMethodV6 } from '@paraswap/sdk';
+
+/*
+  README
+  ======
+
+  This test script should add e2e tests for MaverickV2. The tests
+  should cover as many cases as possible. Most of the DEXes follow
+  the following test structure:
+    - DexName
+      - ForkName + Network
+        - ContractMethod
+          - ETH -> Token swap
+          - Token -> ETH swap
+          - Token -> Token swap
+
+  The template already enumerates the basic structure which involves
+  testing simpleSwap, multiSwap, megaSwap contract methods for
+  ETH <> TOKEN and TOKEN <> TOKEN swaps. You should replace tokenA and
+  tokenB with any two highly liquid tokens on MaverickV2 for the tests
+  to work. If the tokens that you would like to use are not defined in
+  Tokens or Holders map, you can update the './tests/constants-e2e'
+
+  Other than the standard cases that are already added by the template
+  it is highly recommended to add test cases which could be specific
+  to testing MaverickV2 (Eg. Tests based on poolType, special tokens,
+  etc).
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-e2e.test.ts`
+
+  e2e tests use the Tenderly fork api. Please add the following to your
+  .env file:
+  TENDERLY_TOKEN=Find this under Account>Settings>Authorization.
+  TENDERLY_ACCOUNT_ID=Your Tenderly account name.
+  TENDERLY_PROJECT=Name of a Tenderly project you have created in your
+  dashboard.
+
+  (This comment should be removed from the final implementation)
+*/
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [ContractMethod.simpleSwap, ContractMethod.swapExactAmountIn],
+    ],
+    // [SwapSide.BUY, [ContractMethod.simpleBuy]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            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,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('MaverickV2 E2E', () => {
+  const dexKey = 'MaverickV2';
+
+  const testCases = [
+    {
+      network: Network.BASE,
+      tokenASymbol: 'MAV',
+      tokenBSymbol: 'PRIME',
+      tokenAAmount: '1000000000000000',
+      tokenBAmount: '1000000000000000',
+    },
+    {
+      network: Network.ARBITRUM,
+      tokenASymbol: 'USDC',
+      tokenBSymbol: 'USDT',
+      tokenAAmount: '100000000',
+      tokenBAmount: '100000000',
+    },
+    {
+      network: Network.BSC,
+      tokenASymbol: 'USDC',
+      tokenBSymbol: 'USDT',
+      tokenAAmount: '100000000',
+      tokenBAmount: '100000000',
+    },
+    {
+      network: Network.MAINNET,
+      tokenASymbol: 'USDC',
+      tokenBSymbol: 'USDT',
+      tokenAAmount: '100000000',
+      tokenBAmount: '100000000',
+    },
+  ];
+
+  testCases.forEach(
+    ({ network, tokenAAmount, tokenBAmount, tokenASymbol, tokenBSymbol }) => {
+      const nativeTokenAmount = '100000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    },
+  );
+});