@paraswap/dex-lib 2.42.4-baseswap → 2.42.4-baseswap.3

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

@@ -11,6 +11,7 @@ import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
 import UniswapV3QuoterV2ABI from '../../abi/uniswap-v3/UniswapV3QuoterV2.abi.json';
 import { Address } from '@paraswap/core';
+import { BaseswapV3 } from '../baseswap-v3/baseswap-v3';
 
 const network = Network.POLYGON;
 const TokenASymbol = 'USDC';
@@ -1239,3 +1240,377 @@ describe('Retro', () => {
     });
   });
 });
+
+describe('BaseswapV3', function () {
+  const dexKey = 'BaseswapV3';
+
+  describe('Base', function () {
+    const network = Network.BASE;
+    const dexHelper = new DummyDexHelper(network);
+
+    let blockNumber: number;
+    let retro: UniswapV3;
+
+    const TokenASymbol = 'USDC';
+    const TokenA = Tokens[network][TokenASymbol];
+
+    const TokenBSymbol = 'WETH';
+    const TokenB = Tokens[network][TokenBSymbol];
+
+    const QuoterV2 = '0x4fDBD73aD4B1DDde594BF05497C15f76308eFfb9';
+
+    beforeEach(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      retro = new UniswapV3(network, dexKey, dexHelper);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      const pools = await retro.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await retro.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 = retro.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            retro,
+            'quoteExactInputSingle',
+            blockNumber,
+            QuoterV2,
+            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 retro.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.BUY,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await retro.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 = retro.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            retro,
+            'quoteExactOutputSingle',
+            blockNumber,
+            QuoterV2,
+            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 TokenASymbol = 'USDbC';
+      const TokenA = Tokens[network][TokenASymbol];
+
+      const TokenBSymbol = 'USDC';
+      const TokenB = Tokens[network][TokenBSymbol];
+
+      const amounts = [
+        0n,
+        6000000n,
+        12000000n,
+        18000000n,
+        24000000n,
+        30000000n,
+        36000000n,
+        42000000n,
+        48000000n,
+        54000000n,
+        60000000n,
+        66000000n,
+        72000000n,
+        78000000n,
+        84000000n,
+        90000000n,
+        96000000n,
+        102000000n,
+        108000000n,
+        114000000n,
+        120000000n,
+        126000000n,
+        132000000n,
+        138000000n,
+        144000000n,
+        150000000n,
+        156000000n,
+        162000000n,
+        168000000n,
+        174000000n,
+        180000000n,
+        186000000n,
+        192000000n,
+        198000000n,
+        204000000n,
+        210000000n,
+        216000000n,
+        222000000n,
+        228000000n,
+        234000000n,
+        240000000n,
+        246000000n,
+        252000000n,
+        258000000n,
+        264000000n,
+        270000000n,
+        276000000n,
+        282000000n,
+        288000000n,
+        294000000n,
+        300000000n,
+      ];
+
+      const pools = await retro.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await retro.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 = retro.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            retro,
+            'quoteExactInputSingle',
+            blockNumber,
+            QuoterV2,
+            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 TokenASymbol = 'DAI';
+      const TokenA = Tokens[network][TokenASymbol];
+
+      const TokenBSymbol = 'USDC';
+      const TokenB = Tokens[network][TokenBSymbol];
+
+      const amountsBuy = [
+        0n,
+        6000000n,
+        12000000n,
+        18000000n,
+        24000000n,
+        30000000n,
+        36000000n,
+        42000000n,
+        48000000n,
+        54000000n,
+        60000000n,
+        66000000n,
+        72000000n,
+        78000000n,
+        84000000n,
+        90000000n,
+        96000000n,
+        102000000n,
+        108000000n,
+        114000000n,
+        120000000n,
+        126000000n,
+        132000000n,
+        138000000n,
+        144000000n,
+        150000000n,
+        156000000n,
+        162000000n,
+        168000000n,
+        174000000n,
+        180000000n,
+        186000000n,
+        192000000n,
+        198000000n,
+        204000000n,
+        210000000n,
+        216000000n,
+        222000000n,
+        228000000n,
+        234000000n,
+        240000000n,
+        246000000n,
+        252000000n,
+        258000000n,
+        264000000n,
+        270000000n,
+        276000000n,
+        282000000n,
+        288000000n,
+        294000000n,
+        300000000n,
+      ];
+
+      const pools = await retro.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.BUY,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await retro.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 = retro.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            retro,
+            'quoteExactOutputSingle',
+            blockNumber,
+            QuoterV2,
+            price.prices,
+            TokenA.address,
+            TokenB.address,
+            fee,
+            amountsBuy,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const poolLiquidity = await retro.getTopPoolsForToken(TokenB.address, 10);
+      console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+      checkPoolsLiquidity(poolLiquidity, TokenB.address, dexKey);
+    });
+  });
+});

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -100,6 +100,7 @@ export class UniswapV3
         'RamsesV2',
         'ChronosV3',
         'Retro',
+        'BaseswapV3',
       ]),
     );
 

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

@@ -1,129 +0,0 @@
-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';
-
-function testForNetwork(
-  network: Network,
-  dexKey: string,
-  tokenASymbol: string,
-  tokenBSymbol: string,
-  tokenAAmount: string,
-  tokenBAmount: string,
-  nativeTokenAmount: string,
-  slippage?: number | undefined,
-) {
-  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.multiSwap,
-        ContractMethod.megaSwap,
-      ],
-    ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-  ]);
-
-  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,
-                undefined,
-                undefined,
-                undefined,
-                slippage,
-              );
-            });
-            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
-              await testE2E(
-                tokens[tokenASymbol],
-                tokens[nativeTokenSymbol],
-                holders[tokenASymbol],
-                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-                undefined,
-                undefined,
-                undefined,
-                slippage,
-              );
-            });
-            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
-              await testE2E(
-                tokens[tokenASymbol],
-                tokens[tokenBSymbol],
-                holders[tokenASymbol],
-                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-                undefined,
-                undefined,
-                undefined,
-                slippage,
-              );
-            });
-          });
-        });
-      }),
-    );
-  });
-}
-
-describe('BaseswapV3 E2E', () => {
-  const dexKey = 'BaseswapV3';
-  describe('Base', () => {
-    const network = Network.BASE;
-
-    const tokenASymbol: string = 'USDC';
-    const tokenBSymbol: string = 'USDbC';
-
-    const tokenAAmount: string = '1000000';
-    const tokenBAmount: string = '1000000';
-    const nativeTokenAmount = '1000000000000000000';
-
-    testForNetwork(
-      network,
-      dexKey,
-      tokenASymbol,
-      tokenBSymbol,
-      tokenAAmount,
-      tokenBAmount,
-      nativeTokenAmount,
-    );
-  });
-});

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

@@ -1,141 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import _ from 'lodash';
-import { BaseswapV3EventPool } from './baseswap-v3-pool';
-import { BaseswapV3Config } from './config';
-import { Network } from '../../constants';
-import { DummyDexHelper } from '../../dex-helper/index';
-import { testEventSubscriber } from '../../../tests/utils-events';
-import { PoolState } from './types';
-import { Interface } from '@ethersproject/abi';
-import ERC20ABI from '../../abi/erc20.json';
-import StateMulticallABI from '../../abi/uniswap-v3/UniswapV3StateMulticall.abi.json';
-import { AbiItem } from 'web3-utils';
-
-jest.setTimeout(300 * 1000);
-const dexKey = 'BaseswapV3';
-const network = Network.BASE;
-const config = BaseswapV3Config[dexKey][network];
-
-async function fetchPoolStateFromContract(
-  baseswapV3Pool: BaseswapV3EventPool,
-  blockNumber: number,
-  poolAddress: string,
-): Promise<PoolState> {
-  const message = `BaseswapV3: ${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 = baseswapV3Pool.generateState(blockNumber);
-  console.log(`Done ${message}`);
-  return state;
-}
-
-describe('BaseswapV3 Event', function () {
-  const poolAddress = '0xEf3C164b0feE8Eb073513E88EcEa280A58cC9945';
-  const poolFeeCode = 450n;
-  const token0 = '0x4200000000000000000000000000000000000006';
-  const token1 = '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA'; // USDbC
-
-  const blockNumbers: { [eventName: string]: number[] } = {
-    ['Swap']: [
-      5574195, 5574217, 5574296, 5574296, 5574369, 5574404, 5574489, 5574522,
-      5574566, 5574579, 5574587, 5574588, 5574611, 5574657, 5574712, 5574737,
-      5574761, 5574806, 5574851, 5574896, 5574918, 5574982, 5575086, 5575110,
-      5575308, 5575378, 5575490, 5575668,
-    ],
-    ['Burn']: [
-      5575845, 5609704, 5609704, 5612315, 5612770, 5616727, 5617522, 5617821,
-      5620232, 5622253,
-    ],
-    // topic0 - 0x7a53080ba414158be7ec69b987b5fb7d07dee101fe85488f0853ae16239d0bde
-    ['Mint']: [
-      5594704, 5595166, 5606630, 5609854, 5612343, 5612386, 5612959, 5613707,
-      5619196, 5620167, 5622035, 5622391, 5644261, 5645562, 5647711, 5649108,
-      5649161, 5649377, 5651799, 5652903,
-    ],
-    // topic0 - 0x973d8d92bb299f4af6ce49b52a8adb85ae46b9f214c4c4fc06ac77401237b133
-    ['SetFeeProtocol']: [],
-    // topic0 - 0xac49e518f90a358f652e4400164f05a5d8f7e35e7747279bc3a93dbf584e125a
-    // There are some events on blockNumbers: 13125816, 12733621, 12591465
-    // But stateMulticall is not deployed at that time. So I just remove that check
-    // I think it is not important actually
-    ['IncreaseObservationCardinalityNext']: [],
-    ['Collect']: [
-      5575845, 5609704, 5612315, 5612770, 5616727, 5617522, 5617821, 5620232,
-      5622253, 5642348, 5643915, 5645799, 5646074, 5647176, 5650388, 5650466,
-      5653068, 5655334, 5655462, 5656401, 5657882, 5658500, 5659898, 5663603,
-      5663999, 5664004, 5670005, 5671343, 5673141,
-    ],
-    ['Flash']: [],
-  };
-
-  describe('BaseswapV3EventPool', () => {
-    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);
-          // await dexHelper.init();
-
-          const logger = dexHelper.getLogger(dexKey);
-
-          // readonly dexHelper: IDexHelper,
-          // parentName: string,
-          // readonly stateMultiContract: Contract,
-          // readonly decodeStateMultiCallResultWithRelativeBitmaps:
-          //   | DecodeStateMultiCallFunc
-          //   | undefined,
-          // readonly erc20Interface: Interface,
-          // protected readonly factoryAddress: Address,
-          // public feeCode: bigint,
-          // token0: Address,
-          // token1: Address,
-          // logger: Logger,
-          // mapKey: string = '',
-          // readonly poolInitCodeHash: string,
-
-          const baseswapV3Pool = new BaseswapV3EventPool(
-            dexHelper,
-            dexKey,
-            new dexHelper.web3Provider.eth.Contract(
-              StateMulticallABI as AbiItem[],
-              config.stateMulticall,
-            ),
-            undefined,
-            new Interface(ERC20ABI),
-            config.factory,
-            poolFeeCode,
-            token0,
-            token1,
-            logger,
-            undefined,
-            config.initHash,
-          );
-
-          // It is done in generateState. But here have to make it manually
-          baseswapV3Pool.poolAddress = poolAddress.toLowerCase();
-          baseswapV3Pool.addressesSubscribed[0] = poolAddress;
-
-          await testEventSubscriber(
-            baseswapV3Pool,
-            baseswapV3Pool.addressesSubscribed,
-            (_blockNumber: number) =>
-              fetchPoolStateFromContract(
-                baseswapV3Pool,
-                _blockNumber,
-                poolAddress,
-              ),
-            blockNumber,
-            `${dexKey}_${poolAddress}`,
-            dexHelper.provider,
-          );
-        });
-      });
-    });
-  });
-});