@paraswap/dex-lib 2.28.9-take-surplus.0 → 2.28.9-take-surplus.1

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,100 @@
+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,
+            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);
+  });
+});

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

@@ -0,0 +1,302 @@
+import { Interface } from '@ethersproject/abi';
+import _ from 'lodash';
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  SimpleExchangeParam,
+  PoolLiquidity,
+  Logger,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
+import { IDex } from '../idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { QuickPerpsData, DexParams } from './types';
+import { QuickPerpsEventPool } from './pool';
+import { SimpleExchange } from '../simple-exchange';
+import { QuickPerpsConfig, Adapters } from './config';
+import { Vault } from './vault';
+import ERC20ABI from '../../abi/erc20.json';
+
+const QuickPerpsGasCost = 300 * 1000;
+
+export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
+  protected pool: QuickPerpsEventPool | null = null;
+  protected supportedTokensMap: { [address: string]: boolean } = {};
+  // supportedTokens is only used by the pooltracker
+  protected supportedTokens: Token[] = [];
+
+  readonly hasConstantPriceLargeAmounts = false;
+  readonly needWrapNative = true;
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(QuickPerpsConfig);
+
+  public static erc20Interface = new Interface(ERC20ABI);
+
+  vaultUSDBalance: number = 0;
+
+  logger: Logger;
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+    protected adapters = Adapters[network],
+    protected params: DexParams = QuickPerpsConfig[dexKey][network],
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+  }
+
+  async initializePricing(blockNumber: number) {
+    const config = await QuickPerpsEventPool.getConfig(
+      this.params,
+      blockNumber,
+      this.dexHelper.multiContract,
+    );
+    config.tokenAddresses.forEach(
+      (token: Address) => (this.supportedTokensMap[token] = true),
+    );
+    this.pool = new QuickPerpsEventPool(
+      this.dexKey,
+      this.network,
+      this.dexHelper,
+      config,
+    );
+    await this.pool.initialize(blockNumber);
+  }
+
+  // Returns the list of contract adapters (name and index)
+  // for a buy/sell. Return null if there are no adapters.
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side];
+  }
+
+  // Returns list of pool identifiers that can be used
+  // for a given swap. poolIdentifiers must be unique
+  // across DEXes.
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if (side === SwapSide.BUY || !this.pool) return [];
+    const srcAddress = this.dexHelper.config
+      .wrapETH(srcToken)
+      .address.toLowerCase();
+    const destAddress = this.dexHelper.config
+      .wrapETH(destToken)
+      .address.toLowerCase();
+    if (
+      srcAddress !== destAddress &&
+      this.supportedTokensMap[srcAddress] &&
+      this.supportedTokensMap[destAddress]
+    ) {
+      return [`${this.dexKey}_${srcAddress}`, `${this.dexKey}_${destAddress}`];
+    }
+    return [];
+  }
+
+  // Returns pool prices for amounts.
+  // If limitPools is defined only pools in limitPools
+  // should be used. If limitPools is undefined then
+  // any pools can be used.
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<QuickPerpsData>> {
+    if (side === SwapSide.BUY || !this.pool) return null;
+    try {
+      const srcAddress = this.dexHelper.config
+        .wrapETH(srcToken)
+        .address.toLowerCase();
+      const destAddress = this.dexHelper.config
+        .wrapETH(destToken)
+        .address.toLowerCase();
+      if (
+        srcAddress === destAddress ||
+        !(
+          this.supportedTokensMap[srcAddress] &&
+          this.supportedTokensMap[destAddress]
+        )
+      )
+        return null;
+      const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
+      const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
+      const pools = [srcPoolIdentifier, destPoolIdentifier];
+      if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
+
+      const unitVolume = getBigIntPow(srcToken.decimals);
+      const prices = await this.pool.getAmountOut(
+        srcAddress,
+        destAddress,
+        [unitVolume, ...amounts],
+        blockNumber,
+      );
+
+      if (!prices) return null;
+
+      return [
+        {
+          prices: prices.slice(1),
+          unit: prices[0],
+          gasCost: QuickPerpsGasCost,
+          exchange: this.dexKey,
+          data: {},
+          poolAddresses: [this.params.vault],
+        },
+      ];
+    } catch (e) {
+      this.logger.error(
+        `Error_getPrices ${srcToken.symbol || srcToken.address}, ${
+          destToken.symbol || destToken.address
+        }, ${side}: `,
+        e,
+      );
+      return null;
+    }
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(
+    poolPrices: PoolPrices<QuickPerpsData>,
+  ): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: QuickPerpsData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: this.params.vault,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: QuickPerpsData,
+    side: SwapSide,
+  ): SimpleExchangeParam {
+    return {
+      callees: [srcToken, this.params.vault],
+      calldata: [
+        QuickPerps.erc20Interface.encodeFunctionData('transfer', [
+          this.params.vault,
+          srcAmount,
+        ]),
+        Vault.interface.encodeFunctionData('swap', [
+          srcToken,
+          destToken,
+          this.augustusAddress,
+        ]),
+      ],
+      values: ['0', '0'],
+      networkFee: '0',
+    };
+  }
+
+  async updatePoolState(): Promise<void> {
+    if (!this.supportedTokens.length) {
+      const tokenAddresses = await QuickPerpsEventPool.getWhitelistedTokens(
+        this.params.vault,
+        'latest',
+        this.dexHelper.multiContract,
+      );
+
+      const decimalsCallData =
+        QuickPerps.erc20Interface.encodeFunctionData('decimals');
+      const tokenBalanceMultiCall = tokenAddresses.map(t => ({
+        target: t,
+        callData: decimalsCallData,
+      }));
+      const res = (
+        await this.dexHelper.multiContract.methods
+          .aggregate(tokenBalanceMultiCall)
+          .call()
+      ).returnData;
+
+      const tokenDecimals = res.map((r: any) =>
+        parseInt(
+          QuickPerps.erc20Interface
+            .decodeFunctionResult('decimals', r)[0]
+            .toString(),
+        ),
+      );
+
+      this.supportedTokens = tokenAddresses.map((t, i) => ({
+        address: t,
+        decimals: tokenDecimals[i],
+      }));
+    }
+
+    const erc20BalanceCalldata = QuickPerps.erc20Interface.encodeFunctionData(
+      'balanceOf',
+      [this.params.vault],
+    );
+    const tokenBalanceMultiCall = this.supportedTokens.map(t => ({
+      target: t.address,
+      callData: erc20BalanceCalldata,
+    }));
+    const res = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(tokenBalanceMultiCall)
+        .call()
+    ).returnData;
+    const tokenBalances = res.map((r: any) =>
+      BigInt(
+        QuickPerps.erc20Interface
+          .decodeFunctionResult('balanceOf', r)[0]
+          .toString(),
+      ),
+    );
+    const tokenBalancesUSD = await Promise.all(
+      this.supportedTokens.map((t, i) =>
+        this.dexHelper.getTokenUSDPrice(t, tokenBalances[i]),
+      ),
+    );
+    this.vaultUSDBalance = tokenBalancesUSD.reduce(
+      (sum: number, curr: number) => sum + curr,
+    );
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    _tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    const tokenAddress = _tokenAddress.toLowerCase();
+    if (!this.supportedTokens.some(t => t.address === tokenAddress)) return [];
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.params.vault,
+        connectorTokens: this.supportedTokens.filter(
+          t => t.address !== tokenAddress,
+        ),
+        liquidityUSD: this.vaultUSDBalance,
+      },
+    ];
+  }
+}