@paraswap/dex-lib 2.34.0 → 2.35.0

package/src/dex/quick-perps/pool.ts

@@ -0,0 +1,372 @@
+import { DeepReadonly } from 'ts-essentials';
+import { lens } from '../../lens';
+import { Address, Logger, MultiCallInput } from '../../types';
+import { ComposedEventSubscriber } from '../../composed-event-subscriber';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { PoolState, DexParams, PoolConfig } from './types';
+import { Api3FeedSubscriber } from '../../lib/api3-feed';
+import { FastPriceFeed } from './fast-price-feed';
+import { VaultPriceFeed } from './vault-price-feed';
+import { Vault } from './vault';
+import { USDQ } from './usdq';
+import { Contract } from 'web3-eth-contract';
+import ReaderABI from '../../abi/quick-perps/reader.json';
+
+const MAX_AMOUNT_IN_CACHE_TTL = 5 * 60;
+
+export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
+  PRICE_PRECISION = 10n ** 30n;
+  USDQ_DECIMALS = 18;
+  BASIS_POINTS_DIVISOR = 10000n;
+
+  vault: Vault<PoolState>;
+  reader: Contract;
+
+  constructor(
+    parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    config: PoolConfig,
+  ) {
+    const api3ServerV1Map = Object.entries(config.api3ServerV1).reduce(
+      (
+        acc: { [address: string]: Api3FeedSubscriber<PoolState> },
+        [key, value],
+      ) => {
+        acc[key] = new Api3FeedSubscriber<PoolState>(
+          value.proxy,
+          value.api3ServerV1,
+          value.dataFeedId,
+          lens<DeepReadonly<PoolState>>().primaryPrices[key],
+          dexHelper.getLogger(
+            `${key} Api3FeedSubscriber for ${parentName}-${network}`,
+          ),
+        );
+        return acc;
+      },
+      {},
+    );
+    const fastPriceFeed = new FastPriceFeed(
+      config.fastPriceFeed,
+      config.fastPriceEvents,
+      config.tokenAddresses,
+      config.fastPriceFeedConfig,
+      lens<DeepReadonly<PoolState>>().secondaryPrices,
+      dexHelper.getLogger(`${parentName}-${network} fastPriceFeed`),
+    );
+    const vaultPriceFeed = new VaultPriceFeed(
+      config.vaultPriceFeedConfig,
+      api3ServerV1Map,
+      fastPriceFeed,
+    );
+    const usdq = new USDQ(
+      config.usdqAddress,
+      lens<DeepReadonly<PoolState>>().usdq,
+      dexHelper.getLogger(`${parentName}-${network} USDQ`),
+    );
+    const vault = new Vault(
+      config.vaultAddress,
+      config.tokenAddresses,
+      config.vaultConfig,
+      vaultPriceFeed,
+      usdq,
+      lens<DeepReadonly<PoolState>>().vault,
+      dexHelper.getLogger(`${parentName}-${network} vault`),
+    );
+    super(
+      parentName,
+      'pool',
+      dexHelper.getLogger(`${parentName}-${network}`),
+      dexHelper,
+      [...Object.values(api3ServerV1Map), fastPriceFeed, usdq, vault],
+      {
+        primaryPrices: {},
+        secondaryPrices: {
+          lastUpdatedAt: 0,
+          prices: {},
+        },
+        vault: {
+          usdqAmounts: {},
+        },
+        usdq: {
+          totalSupply: 0n,
+        },
+      },
+    );
+    this.vault = vault;
+    this.reader = new this.dexHelper.web3Provider.eth.Contract(
+      ReaderABI as any,
+      config.readerAddress,
+    );
+  }
+
+  async getStateOrGenerate(blockNumber: number): Promise<Readonly<PoolState>> {
+    const evenState = this.getState(blockNumber);
+    if (evenState) return evenState;
+    const onChainState = await this.generateState(blockNumber);
+    this.setState(onChainState, blockNumber);
+    return onChainState;
+  }
+
+  async getMaxAmountIn(_tokenIn: Address, _tokenOut: Address): Promise<bigint> {
+    const cacheKey = `maxAmountIn_${_tokenIn}_${_tokenOut}`;
+    const maxAmountCached = await this.dexHelper.cache.get(
+      this.parentName,
+      this.network,
+      cacheKey,
+    );
+    if (maxAmountCached) return BigInt(maxAmountCached);
+    const maxAmount: string = await this.reader.methods
+      .getMaxAmountIn(this.vault.vaultAddress, _tokenIn, _tokenOut)
+      .call();
+    this.dexHelper.cache.setex(
+      this.parentName,
+      this.network,
+      cacheKey,
+      MAX_AMOUNT_IN_CACHE_TTL,
+      maxAmount,
+    );
+    return BigInt(maxAmount);
+  }
+
+  // Reference to the original implementation
+  // https://github.com/gmx-io/gmx-contracts/blob/master/contracts/peripherals/Reader.sol#L71
+  async getAmountOut(
+    _tokenIn: Address,
+    _tokenOut: Address,
+    _amountsIn: bigint[],
+    blockNumber: number,
+  ): Promise<bigint[] | null> {
+    const maxAmountIn = await this.getMaxAmountIn(_tokenIn, _tokenOut);
+    const state = await this.getStateOrGenerate(blockNumber);
+    const priceIn = this.vault.getMinPrice(state, _tokenIn);
+    const priceOut = this.vault.getMaxPrice(state, _tokenOut);
+
+    const tokenInDecimals = this.vault.tokenDecimals[_tokenIn];
+    const tokenOutDecimals = this.vault.tokenDecimals[_tokenOut];
+
+    const isStableSwap =
+      this.vault.stableTokens[_tokenIn] && this.vault.stableTokens[_tokenOut];
+    const baseBps = isStableSwap
+      ? this.vault.stableSwapFeeBasisPoints
+      : this.vault.swapFeeBasisPoints;
+    const taxBps = isStableSwap
+      ? this.vault.stableTaxBasisPoints
+      : this.vault.taxBasisPoints;
+    const USDQUnit = BigInt(10 ** this.USDQ_DECIMALS);
+    const tokenInUnit = BigInt(10 ** tokenInDecimals);
+    const tokenOutUnit = BigInt(10 ** tokenOutDecimals);
+
+    return _amountsIn.map(_amountIn => {
+      if (_amountIn > maxAmountIn) return 0n;
+      let feeBasisPoints;
+      {
+        let usdqAmount = (_amountIn * priceIn) / this.PRICE_PRECISION;
+        usdqAmount = (usdqAmount * USDQUnit) / tokenInUnit;
+
+        const feesBasisPoints0 = this.vault.getFeeBasisPoints(
+          state,
+          _tokenIn,
+          usdqAmount,
+          baseBps,
+          taxBps,
+          true,
+        );
+        const feesBasisPoints1 = this.vault.getFeeBasisPoints(
+          state,
+          _tokenOut,
+          usdqAmount,
+          baseBps,
+          taxBps,
+          false,
+        );
+        // use the higher of the two fee basis points
+        feeBasisPoints =
+          feesBasisPoints0 > feesBasisPoints1
+            ? feesBasisPoints0
+            : feesBasisPoints1;
+      }
+
+      let amountOut = (_amountIn * priceIn) / priceOut;
+      amountOut = (amountOut * tokenOutUnit) / tokenInUnit;
+
+      const amountOutAfterFees =
+        (amountOut * (this.BASIS_POINTS_DIVISOR - feeBasisPoints)) /
+        this.BASIS_POINTS_DIVISOR;
+      return amountOutAfterFees;
+    });
+  }
+
+  static async getWhitelistedTokens(
+    vaultAddress: Address,
+    blockNumber: number | 'latest',
+    multiContract: Contract,
+  ) {
+    // get tokens count
+    const tokenCountResult = (
+      await multiContract.methods
+        .aggregate([
+          {
+            callData: Vault.interface.encodeFunctionData(
+              'allWhitelistedTokensLength',
+            ),
+            target: vaultAddress,
+          },
+        ])
+        .call({}, blockNumber)
+    ).returnData;
+    const tokensCount = parseInt(
+      Vault.interface
+        .decodeFunctionResult('allWhitelistedTokensLength', tokenCountResult[0])
+        .toString(),
+    );
+
+    // get tokens
+    const getTokensCalldata = new Array(tokensCount).fill(0).map((_, i) => {
+      return {
+        callData: Vault.interface.encodeFunctionData('allWhitelistedTokens', [
+          i,
+        ]),
+        target: vaultAddress,
+      };
+    });
+    const tokensResult = (
+      await multiContract.methods
+        .aggregate(getTokensCalldata)
+        .call({}, blockNumber)
+    ).returnData;
+    const tokens: Address[] = tokensResult.map((t: any) =>
+      Vault.interface
+        .decodeFunctionResult('allWhitelistedTokens', t)[0]
+        .toLowerCase(),
+    );
+    return tokens;
+  }
+
+  static async getConfig(
+    dexParams: DexParams,
+    blockNumber: number | 'latest',
+    multiContract: Contract,
+  ): Promise<PoolConfig> {
+    const tokens = await this.getWhitelistedTokens(
+      dexParams.vault,
+      blockNumber,
+      multiContract,
+    );
+
+    // get price chainlink price feed
+    const getPriceFeedCalldata = tokens.map(t => {
+      return {
+        callData: VaultPriceFeed.interface.encodeFunctionData(
+          'priceFeedProxies',
+          [t],
+        ),
+        target: dexParams.priceFeed,
+      };
+    });
+    const priceFeedResult = (
+      await multiContract.methods
+        .aggregate(getPriceFeedCalldata)
+        .call({}, blockNumber)
+    ).returnData;
+    const priceFeeds = priceFeedResult.map((p: any) =>
+      VaultPriceFeed.interface
+        .decodeFunctionResult('priceFeedProxies', p)[0]
+        .toString()
+        .toLowerCase(),
+    );
+
+    // get config for all event listeners
+    let multicallSlices: [number, number][] = [];
+    let multiCallData: MultiCallInput[] = [];
+    let i = 0;
+    for (let priceFeed of priceFeeds) {
+      const api3ServerAddressCallData =
+        Api3FeedSubscriber.getApi3ServerV1MultiCallInput(priceFeed);
+      const dataFeedIdCallData = Api3FeedSubscriber.getDataFeedId(priceFeed);
+      multiCallData.push(...[api3ServerAddressCallData, dataFeedIdCallData]);
+      multicallSlices.push([i, i + 2]);
+      i += 2;
+    }
+
+    const fastPriceFeedConfigCallData = FastPriceFeed.getConfigMulticallInputs(
+      dexParams.fastPriceFeed,
+      tokens,
+    );
+    multiCallData.push(...fastPriceFeedConfigCallData);
+    multicallSlices.push([i, i + fastPriceFeedConfigCallData.length]);
+    i += fastPriceFeedConfigCallData.length;
+
+    const vaultPriceFeedConfigCallData =
+      VaultPriceFeed.getConfigMulticallInputs(dexParams.priceFeed, tokens);
+    multiCallData.push(...vaultPriceFeedConfigCallData);
+    multicallSlices.push([i, i + vaultPriceFeedConfigCallData.length]);
+    i += vaultPriceFeedConfigCallData.length;
+
+    const vaultConfigCallData = Vault.getConfigMulticallInputs(
+      dexParams.vault,
+      tokens,
+    );
+    multiCallData.push(...vaultConfigCallData);
+    multicallSlices.push([i, i + vaultConfigCallData.length]);
+    i += vaultConfigCallData.length;
+
+    const configResults = (
+      await multiContract.methods.aggregate(multiCallData).call({}, blockNumber)
+    ).returnData;
+
+    const api3ServerV1: {
+      [address: string]: {
+        proxy: Address;
+        api3ServerV1: Address;
+        dataFeedId: string;
+      };
+    } = {};
+    for (let token of tokens) {
+      const [api3ServerAddressRes, dataFeedIdRes] = configResults.slice(
+        ...multicallSlices.shift()!,
+      );
+      const serverV1Address =
+        Api3FeedSubscriber.decodeApi3ServerV1Result(api3ServerAddressRes);
+      const dataFeedId = Api3FeedSubscriber.decodeDataFeedId(dataFeedIdRes);
+      api3ServerV1[token] = {
+        proxy: priceFeeds.shift(),
+        api3ServerV1: serverV1Address,
+        dataFeedId,
+      };
+    }
+
+    const fastPriceFeedConfigResults = configResults.slice(
+      ...multicallSlices.shift()!,
+    );
+    const fastPriceFeedConfig = FastPriceFeed.getConfig(
+      fastPriceFeedConfigResults,
+      tokens,
+    );
+
+    const vaultPriceFeedConfigResults = configResults.slice(
+      ...multicallSlices.shift()!,
+    );
+    const vaultPriceFeedConfig = VaultPriceFeed.getConfig(
+      vaultPriceFeedConfigResults,
+      tokens,
+    );
+
+    const vaultConfigResults = configResults.slice(...multicallSlices.shift()!);
+    const vaultConfig = Vault.getConfig(vaultConfigResults, tokens);
+
+    return {
+      vaultAddress: dexParams.vault,
+      readerAddress: dexParams.reader,
+      priceFeed: dexParams.priceFeed,
+      fastPriceFeed: dexParams.fastPriceFeed,
+      fastPriceEvents: dexParams.fastPriceEvents,
+      usdqAddress: dexParams.usdq,
+      tokenAddresses: tokens,
+      vaultConfig,
+      vaultPriceFeedConfig,
+      fastPriceFeedConfig,
+      api3ServerV1,
+    };
+  }
+}

package/src/dex/quick-perps/quick-perps-e2e.test.ts

@@ -0,0 +1,65 @@
+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('QuickPerps E2E', () => {
+  const dexKey = 'QuickPerps';
+
+  describe('QuickPerps zkEVM', () => {
+    const network = Network.ZKEVM;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokenASymbol: string = 'ETH';
+    const tokenBSymbol: string = 'MATIC';
+
+    const tokenAAmount: string = '100000000000000000';
+    const tokenBAmount: string = '10000000000000000000';
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        describe(`${contractMethod}`, () => {
+          it('ETH -> MATIC', async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[tokenBSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+              undefined,
+              undefined,
+              undefined,
+              undefined,
+              undefined,
+              true,
+            );
+          });
+        });
+      }),
+    );
+  });
+});

package/src/dex/quick-perps/quick-perps-events.test.ts

@@ -0,0 +1,101 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { QuickPerpsEventPool } from './pool';
+import { QuickPerpsConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolConfig, PoolState } from './types';
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'QuickPerps';
+const network = Network.ZKEVM;
+const params = QuickPerpsConfig[dexKey][network];
+const dexHelper = new DummyDexHelper(network);
+const logger = dexHelper.getLogger(dexKey);
+
+async function fetchPoolState(
+  quickPerpsPool: QuickPerpsEventPool,
+  blockNumber: number,
+): Promise<PoolState> {
+  return quickPerpsPool.generateState(blockNumber);
+}
+
+// timestamp can't be compared exactly as the event released
+// doesn't have the timestamp. It is safe to consider the
+// timestamp as the blockTime as the max deviation is bounded
+// on the contract
+const stateWithoutTimestamp = (state: PoolState) => ({
+  ...state,
+  secondaryPrices: {
+    prices: state.secondaryPrices.prices,
+  },
+});
+
+function compareState(state: PoolState, expectedState: PoolState) {
+  expect(stateWithoutTimestamp(state)).toEqual(
+    stateWithoutTimestamp(expectedState),
+  );
+}
+
+describe('QuickPerps Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    IncreaseUsdqAmount: [
+      4960808, 4960808, 4961034, 4961037, 4961046, 4961052, 4961055, 4961062,
+      4961153, 4961167, 4961190, 4961194, 4961215, 4961220, 4961353, 4961472,
+      4961476, 4961521, 4961628, 4961629, 4961648, 4961664, 4961683, 4961710,
+      4961716, 4961848, 4961853, 4961863, 4961866, 4962156, 4962180, 4962200,
+      4962296,
+    ],
+    DecreaseUsdqAmount: [
+      4960808, 4960808, 4961034, 4961037, 4961046, 4961052, 4961055, 4961062,
+      4961153, 4961167, 4961190, 4961194, 4961215, 4961220, 4961353, 4961472,
+      4961476, 4961521, 4961628, 4961629, 4961648, 4961664, 4961683, 4961710,
+      4961716, 4961848, 4961853, 4961863, 4961866, 4962156, 4962180, 4962200,
+      4962296,
+    ],
+    Transfer: [4958541, 4959994, 4959998, 4960452, 4960452],
+    PriceUpdate: [
+      4960534, 4960569, 4960584, 4960609, 4960637, 4960660, 4960694, 4960700,
+    ],
+  };
+
+  describe('QuickPerpsEventPool', function () {
+    let config: PoolConfig;
+    let quickPerpsPool: QuickPerpsEventPool;
+    let blockNumber: number;
+    beforeAll(async function () {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+
+      config = await QuickPerpsEventPool.getConfig(
+        params,
+        blockNumber,
+        dexHelper.multiContract,
+      );
+    });
+    Object.keys(blockNumbers).forEach((event: string) => {
+      blockNumbers[event].forEach((blockNumber: number) => {
+        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+          quickPerpsPool = new QuickPerpsEventPool(
+            dexKey,
+            network,
+            dexHelper,
+            logger,
+            config,
+          );
+          await testEventSubscriber(
+            quickPerpsPool,
+            quickPerpsPool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolState(quickPerpsPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${params.vault}`,
+            dexHelper.provider,
+            compareState,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/quick-perps/quick-perps-integration.test.ts

@@ -0,0 +1,153 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { QuickPerps } from './quick-perps';
+import { QuickPerpsConfig } from './config';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import ReaderABI from '../../abi/quick-perps/reader.json';
+
+const network = Network.ZKEVM;
+const dexKey = 'QuickPerps';
+const params = QuickPerpsConfig[dexKey][network];
+const readerInterface = new Interface(ReaderABI);
+const readerAddress = '0xf1CFB75854DE535475B88Bb6FBad317eea98c0F9';
+
+function testsForCase(
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  amounts: bigint[],
+) {
+  const TokenA = Tokens[network][tokenASymbol];
+  const TokenB = Tokens[network][tokenBSymbol];
+
+  it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const quickPerps = new QuickPerps(network, dexKey, dexHelper);
+
+    await quickPerps.initializePricing(blocknumber);
+
+    const pools = await quickPerps.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${tokenASymbol} <> ${tokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await quickPerps.getPricesVolume(
+      TokenA,
+      TokenB,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${tokenASymbol} <> ${tokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    if (quickPerps.hasConstantPriceLargeAmounts) {
+      checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+    } else {
+      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+    }
+
+    // Do on chain pricing based on reader to compare
+    const readerCallData = amounts.map(a => ({
+      target: readerAddress,
+      callData: readerInterface.encodeFunctionData('getAmountOut', [
+        params.vault,
+        TokenA.address,
+        TokenB.address,
+        a.toString(),
+      ]),
+    }));
+
+    const readerResult = (
+      await dexHelper.multiContract.methods
+        .aggregate(readerCallData)
+        .call({}, blocknumber)
+    ).returnData;
+    const expectedPrices = readerResult.map((p: any) =>
+      BigInt(
+        readerInterface.decodeFunctionResult('getAmountOut', p)[0].toString(),
+      ),
+    );
+
+    expect(poolPrices![0].prices).toEqual(expectedPrices);
+  });
+
+  it('getTopPoolsForToken', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const quickPerps = new QuickPerps(network, dexKey, dexHelper);
+
+    await quickPerps.updatePoolState();
+    const poolLiquidity = await quickPerps.getTopPoolsForToken(
+      TokenA.address,
+      10,
+    );
+    console.log(
+      `${tokenASymbol} Top Pools:`,
+      JSON.stringify(poolLiquidity, null, 2),
+    );
+
+    if (!quickPerps.hasConstantPriceLargeAmounts) {
+      checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+    }
+  });
+}
+
+describe('QuickPerps', function () {
+  describe('WETH -> MATIC', function () {
+    const TokenASymbol = 'WETH';
+    const TokenBSymbol = 'MATIC';
+
+    const amounts = [
+      0n,
+      100000000000000000n,
+      200000000000000000n,
+      300000000000000000n,
+      400000000000000000n,
+      500000000000000000n,
+      600000000000000000n,
+      700000000000000000n,
+      800000000000000000n,
+      900000000000000000n,
+      1000000000000000000n,
+    ];
+
+    testsForCase(TokenASymbol, TokenBSymbol, amounts);
+  });
+
+  describe('WBTC -> USDC', function () {
+    const TokenASymbol = 'WBTC';
+    const TokenBSymbol = 'USDC';
+
+    const amounts = [
+      0n,
+      100000000n,
+      200000000n,
+      300000000n,
+      400000000n,
+      500000000n,
+      600000000n,
+      700000000n,
+      800000000n,
+      900000000n,
+      1000000000n,
+    ];
+
+    testsForCase(TokenASymbol, TokenBSymbol, amounts);
+  });
+});