@paraswap/dex-lib 2.16.7 → 2.16.8-pancakeswapv3.0

package/src/dex/pancakeswap-v3/pancakeswap-v3-e2e.test.ts

@@ -0,0 +1,168 @@
+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';
+
+describe('PancakeswapV3 E2E', () => {
+  const dexKey = 'PancakeswapV3';
+
+  describe('PancakeswapV3 MAINNET', () => {
+    const network = Network.MAINNET;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokenASymbol: string = 'USDT';
+    const tokenBSymbol: string = 'USDC';
+    const nativeTokenSymbol = NativeTokenSymbols[network];
+
+    const tokenAAmount: string = '100000000';
+    const tokenBAmount: string = '100000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        describe(`${contractMethod}`, () => {
+          it(`${network} ${side} ${contractMethod} ${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+            await testE2E(
+              tokens[nativeTokenSymbol],
+              tokens[tokenASymbol],
+              holders[nativeTokenSymbol],
+              side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[nativeTokenSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[tokenBSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+        });
+      }),
+    );
+  });
+
+  describe('PancakeswapV3 BSC', () => {
+    const network = Network.BSC;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokenASymbol: string = 'BUSD';
+    const tokenBSymbol: string = 'WBNB';
+    const nativeTokenSymbol = NativeTokenSymbols[network];
+
+    const tokenAAmount: string = '100000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        describe(`${contractMethod}`, () => {
+          it(`${network} ${side} ${contractMethod} ${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+            await testE2E(
+              tokens[nativeTokenSymbol],
+              tokens[tokenASymbol],
+              holders[nativeTokenSymbol],
+              side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[nativeTokenSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[tokenBSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+        });
+      }),
+    );
+  });
+});

package/src/dex/pancakeswap-v3/pancakeswap-v3-events.test.ts

@@ -0,0 +1,124 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { PancakeswapV3Config } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { Interface } from '@ethersproject/abi';
+import ERC20ABI from '../../abi/erc20.json';
+import StateMulticallABI from '../../abi/pancakeswap-v3/PancakeV3StateMulticall.abi.json';
+import { AbiItem } from 'web3-utils';
+import { PancakeSwapV3EventPool } from './pancakeswap-v3-pool';
+import { PoolState } from '../uniswap-v3/types';
+
+jest.setTimeout(300 * 1000);
+const dexKey = 'PancakeswapV3';
+const network = Network.MAINNET;
+const config = PancakeswapV3Config[dexKey][network];
+
+async function fetchPoolStateFromContract(
+  pancakeswapV3Pool: PancakeSwapV3EventPool,
+  blockNumber: number,
+  poolAddress: string,
+): Promise<PoolState | undefined> {
+  const message = `PancakeswapV3: ${poolAddress} blockNumber ${blockNumber}`;
+  console.log(`Fetching state ${message}`);
+  // Be careful to not request state prior to contract deployment
+  // Otherwise need to use manual state sourcing from multicall
+  // We had that mechanism, but removed it with this commit
+  // You can restore it, but better just to find block after state multicall
+  // deployment
+  const state = await pancakeswapV3Pool.generateState(blockNumber);
+
+  console.log(`Done ${message}`);
+
+  return state;
+}
+
+describe('PancakeswapV3 Event', function () {
+  const poolAddress = '0x04c8577958CcC170EB3d2CCa76F9d51bc6E42D8f';
+  const poolFeeCode = 100n;
+  const token0 = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+  const token1 = '0xdAC17F958D2ee523a2206206994597C13D831ec7';
+
+  const blockNumbers: { [eventName: string]: number[] } = {
+    ['Swap']: [
+      17030597, 17031935, 17032362, 17035931, 17038708, 17039103, 17039688,
+      17039812, 17046030, 17046317, 17046694, 17047063, 17047219, 17056731,
+      17057640, 17057862, 17057892, 17057955, 17063052, 17063127, 17063524,
+      17091869, 17093155, 17093506, 17146325, 17146863, 17147474, 17147830,
+      17154952, 17159976, 17160283, 17160720, 17233700, 17234168, 17234407,
+      17234433, 17242498, 17242712, 17243089, 17276770, 17277552, 17277733,
+      17320467,
+    ],
+    ['Burn']: [
+      17030970, 17031054, 17031107, 17031773, 17031838, 17033280, 17036092,
+      17042331, 17042392, 17043224, 17097388, 17098794, 17099011, 17118506,
+      17121704, 17143519, 17163847, 17207834, 17213897, 17249508, 17251725,
+    ],
+    ['Mint']: [
+      17030284, 17031045, 17033298, 17033315, 17036173, 17042433, 17043299,
+      17044836, 17044855, 17046316, 17047699, 17047732, 17050119, 17071407,
+      17074384, 17090265, 17092669, 17093251, 17094015, 17121836, 17147932,
+      17163857, 17172266, 17185894, 17194153, 17199371, 17249453,
+    ],
+    ['SetFeeProtocol']: [],
+    ['IncreaseObservationCardinalityNext']: [],
+    ['Collect']: [
+      17117306, 17118506, 17121704, 17143519, 17147612, 17160005, 17163847,
+      17192312, 17201868, 17205784, 17207834, 17213120, 17213897, 17241053,
+      17249508, 17251725,
+    ],
+    ['Flash']: [],
+  };
+
+  describe('PancakeswapV3EventPool', function () {
+    Object.keys(blockNumbers).forEach((event: string) => {
+      blockNumbers[event].forEach((blockNumber: number) => {
+        it(`${event}:${blockNumber} - should return correct state`, async function () {
+          const dexHelper = new DummyDexHelper(network);
+
+          const logger = dexHelper.getLogger(dexKey);
+
+          const pancakeswapV3Pool = new PancakeSwapV3EventPool(
+            dexHelper,
+            dexKey,
+            new dexHelper.web3Provider.eth.Contract(
+              StateMulticallABI as AbiItem[],
+              config.stateMulticall,
+            ),
+            new Interface(ERC20ABI),
+            config.factory,
+            poolFeeCode,
+            token0,
+            token1,
+            logger,
+            undefined,
+            config.initHash,
+            config.deployer,
+          );
+
+          // It is done in generateState. But here have to make it manually
+          pancakeswapV3Pool.poolAddress = poolAddress.toLowerCase();
+          pancakeswapV3Pool.addressesSubscribed[0] = poolAddress;
+
+          await testEventSubscriber(
+            pancakeswapV3Pool,
+            pancakeswapV3Pool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolStateFromContract(
+                pancakeswapV3Pool,
+                _blockNumber,
+                poolAddress,
+              ),
+            blockNumber,
+            `${dexKey}_${poolAddress}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/pancakeswap-v3/pancakeswap-v3-integration.test.ts

@@ -0,0 +1,338 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface, Result } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import PancakeswapV3QuoterABI from '../../abi/pancakeswap-v3/PancakeswapV3Quoter.abi.json';
+import { Address } from '@paraswap/core';
+import { PancakeswapV3 } from './pancakeswap-v3';
+
+const network = Network.MAINNET;
+const TokenASymbol = 'USDC';
+const TokenA = Tokens[network][TokenASymbol];
+
+const TokenBSymbol = 'USDT';
+const TokenB = Tokens[network][TokenBSymbol];
+
+const amounts = [
+  0n,
+  10_000n * BI_POWS[6],
+  20_000n * BI_POWS[6],
+  30_000n * BI_POWS[6],
+];
+
+const amountsBuy = [0n, 1n * BI_POWS[6], 2n * BI_POWS[6], 3n * BI_POWS[6]];
+
+const dexHelper = new DummyDexHelper(network);
+const dexKey = 'PancakeswapV3';
+
+const quoterIface = new Interface(PancakeswapV3QuoterABI);
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  amounts: bigint[],
+  funcName: string,
+  tokenIn: Address,
+  tokenOut: Address,
+  fee: bigint,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(funcName, [
+      [tokenIn, tokenOut, amount, fee, 0n],
+    ]),
+  }));
+}
+
+function decodeReaderResult(
+  results: Result,
+  readerIface: Interface,
+  funcName: string,
+) {
+  return results.map(result => {
+    const parsed = readerIface.decodeFunctionResult(funcName, result);
+    return BigInt(parsed[0]._hex);
+  });
+}
+
+async function checkOnChainPricing(
+  pancakeswapV3: PancakeswapV3,
+  funcName: string,
+  blockNumber: number,
+  prices: bigint[],
+  tokenIn: Address,
+  tokenOut: Address,
+  fee: bigint,
+  _amounts: bigint[],
+) {
+  // Quoter address
+  const exchangeAddress = '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997';
+  const readerIface = quoterIface;
+
+  const sum = prices.reduce((acc, curr) => (acc += curr), 0n);
+
+  if (sum === 0n) {
+    console.log(
+      `Prices were not calculated for tokenIn=${tokenIn}, tokenOut=${tokenOut}, fee=${fee.toString()}. Most likely price impact is too big for requested amount`,
+    );
+    return false;
+  }
+
+  const readerCallData = getReaderCalldata(
+    exchangeAddress,
+    readerIface,
+    _amounts.slice(1),
+    funcName,
+    tokenIn,
+    tokenOut,
+    fee,
+  );
+
+  let readerResult;
+  try {
+    readerResult = (
+      await dexHelper.multiContract.methods
+        .aggregate(readerCallData)
+        .call({}, blockNumber)
+    ).returnData;
+  } catch (e) {
+    console.log(
+      `Can not fetch on-chain pricing for fee ${fee}. It happens for low liquidity pools`,
+      e,
+    );
+    return false;
+  }
+
+  const expectedPrices = [0n].concat(
+    decodeReaderResult(readerResult, readerIface, funcName),
+  );
+
+  let firstZeroIndex = prices.slice(1).indexOf(0n);
+
+  // we skipped first, so add +1 on result
+  firstZeroIndex = firstZeroIndex === -1 ? prices.length : firstZeroIndex;
+
+  // Compare only the ones for which we were able to calculate prices
+  expect(prices.slice(0, firstZeroIndex)).toEqual(
+    expectedPrices.slice(0, firstZeroIndex),
+  );
+  return true;
+}
+
+describe('PancakeswapV3', function () {
+  let blockNumber: number;
+  let pancakeswapV3: PancakeswapV3;
+
+  beforeEach(async () => {
+    blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    pancakeswapV3 = new PancakeswapV3(network, dexKey, dexHelper);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+    const pools = await pancakeswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.SELL,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await pancakeswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amounts,
+      SwapSide.SELL,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = pancakeswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          pancakeswapV3,
+          'quoteExactInputSingle',
+          blockNumber,
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amounts,
+        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+    const pools = await pancakeswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.BUY,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await pancakeswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amountsBuy,
+      SwapSide.BUY,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amountsBuy, SwapSide.BUY, dexKey);
+
+    // Check if onchain pricing equals to calculated ones
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = pancakeswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          pancakeswapV3,
+          'quoteExactOutputSingle',
+          blockNumber,
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amountsBuy,
+        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume SELL stable pairs', async function () {
+    const pools = await pancakeswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.SELL,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await pancakeswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amounts,
+      SwapSide.SELL,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(
+      poolPrices!.filter(pp => pp.unit !== 0n),
+      amounts,
+      SwapSide.SELL,
+      dexKey,
+    );
+
+    // Check if onchain pricing equals to calculated ones
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = pancakeswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          pancakeswapV3,
+          'quoteExactInputSingle',
+          blockNumber,
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amounts,
+        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume BUY stable pairs', async function () {
+    const pools = await pancakeswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.BUY,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await pancakeswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amountsBuy,
+      SwapSide.BUY,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(
+      poolPrices!.filter(pp => pp.unit !== 0n),
+      amountsBuy,
+      SwapSide.BUY,
+      dexKey,
+    );
+
+    // Check if onchain pricing equals to calculated ones
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = pancakeswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          pancakeswapV3,
+          'quoteExactOutputSingle',
+          blockNumber,
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amountsBuy,
+        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
+
+  it('getTopPoolsForToken', async function () {
+    const poolLiquidity = await pancakeswapV3.getTopPoolsForToken(
+      Tokens[Network.MAINNET]['USDC'].address,
+      10,
+    );
+    console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+    if (!pancakeswapV3.hasConstantPriceLargeAmounts) {
+      checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+    }
+  });
+});