@paraswap/dex-lib 2.42.28 → 2.42.29

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

@@ -0,0 +1,124 @@
+/* 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';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  pairs: { name: string; sellAmount: string; buyAmount: string }[][],
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+  ]);
+
+  sideToContractMethods.forEach((contractMethods, side) =>
+    describe(`${side}`, () => {
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        pairs.forEach(pair => {
+          describe(`${contractMethod}`, () => {
+            it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+              await testE2E(
+                tokens[pair[0].name],
+                tokens[pair[1].name],
+                holders[pair[0].name],
+                side === SwapSide.SELL ? pair[0].sellAmount : pair[0].buyAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+              await testE2E(
+                tokens[pair[1].name],
+                tokens[pair[0].name],
+                holders[pair[1].name],
+                side === SwapSide.SELL ? pair[1].sellAmount : pair[1].buyAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      });
+    }),
+  );
+}
+
+describe('SolidlyV3 E2E', () => {
+  const dexKey = 'SolidlyV3';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const pairs = [
+      [
+        {
+          name: 'ETH',
+          sellAmount: '110000000000000000',
+          buyAmount: '1100000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '400000000',
+          buyAmount: '4000000',
+        },
+      ],
+      [
+        {
+          name: 'WETH',
+          sellAmount: '1100000000000000000',
+          buyAmount: '1100000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '400000000',
+          buyAmount: '4000000',
+        },
+      ],
+      [
+        {
+          name: 'USDC',
+          sellAmount: '400000000',
+          buyAmount: '4000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '500000000',
+          buyAmount: '5000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+});

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

@@ -0,0 +1,144 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { SolidlyV3EventPool } from './solidly-v3-pool';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolState } from './types';
+import {SolidlyV3Config} from "./config";
+import {AbiItem} from "web3-utils";
+import {Interface} from "@ethersproject/abi";
+import StateMulticallABI from '../../abi/solidly-v3/SolidlyV3StateMulticall.abi.json';
+import { decodeStateMultiCallResultWithRelativeBitmaps } from './utils';
+import ERC20ABI from '../../abi/erc20.json';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for SolidlyV3 event based
+  system. This is done by fetching the state on-chain before the
+  event block, manually pushing the block logs to the event-subscriber,
+  comparing the local state with on-chain state.
+
+  Most of the logic for testing is abstracted by `testEventSubscriber`.
+  You need to do two things to make the tests work:
+
+  1. Fetch the block numbers where certain events were released. You
+  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
+  block numbers for different events. Make sure to get sufficient
+  number of blockNumbers to cover all possible cases for the event
+  mutations.
+
+  2. Complete the implementation for fetchPoolState function. The
+  function should fetch the on-chain state of the event subscriber
+  using just the blocknumber.
+
+  The template tests only include the test for a single event
+  subscriber. There can be cases where multiple event subscribers
+  exist for a single DEX. In such cases additional tests should be
+  added.
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-events.test.ts`
+
+  (This comment should be removed from the final implementation)
+*/
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'SolidlyV3';
+const network = Network.MAINNET;
+const config = SolidlyV3Config[dexKey][network];
+
+async function fetchPoolStateFromContract(
+  solidlyV3Pool: SolidlyV3EventPool,
+  blockNumber: number,
+  poolAddress: string,
+): Promise<PoolState> {
+  const message = `SolidlyV3: ${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 = solidlyV3Pool.generateState(blockNumber);
+  console.log(`Done ${message}`);
+  return state;
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+describe('SolidlyV3 Event', function () {
+  const poolAddress = '0x831BF48183B999fDe45294b14B55199072f0801B';
+  const token0 = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+  const token1 = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
+
+  const blockNumbers: { [eventName: string]: number[] } = {
+    // topic0 - 0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67
+    ['Swap']: [
+      18600853, 18616106, 18616441, 18619851, 18622968, 18625121, 18626415, 18627297, 18630574,
+      18718946, 18726197, 18730166, 18758602
+    ],
+    ['Burn']: [18737937],
+    ['Mint']: [18708230, 18709265, 18737969],
+    ['Collect']: [18751597],
+    //topic0 0x0eb63f4a36d6bdeee05aa00020a97d80c3e84f1b5b3ebf345fb67262e62b0f33
+    ['SetFee']: [18427614, 18423073, 18423143, 18425324, 18430069, 18442932, 18442934],
+    ['Flash']: [18758872],
+    ['CollectProtocol']: [18530529, 18577493],
+  }
+
+  describe('SolidlyV3EventPool', 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);
+          // await dexHelper.init();
+
+          const logger = dexHelper.getLogger(dexKey);
+
+          const solidlyV3Pool = new SolidlyV3EventPool(
+            dexHelper,
+            dexKey,
+            new dexHelper.web3Provider.eth.Contract(
+              StateMulticallABI as AbiItem[],
+              config.stateMulticall,
+            ),
+            decodeStateMultiCallResultWithRelativeBitmaps,
+            new Interface(ERC20ABI),
+            config.factory,
+            10n,
+            token0,
+            token1,
+            logger,
+            undefined,
+            config.initHash,
+          );
+
+          // It is done in generateState. But here have to make it manually
+          solidlyV3Pool.poolAddress = poolAddress.toLowerCase();
+          solidlyV3Pool.addressesSubscribed[0] = poolAddress;
+
+          await testEventSubscriber(
+            solidlyV3Pool,
+            solidlyV3Pool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolStateFromContract(
+                solidlyV3Pool,
+                _blockNumber,
+                poolAddress,
+              ),
+            blockNumber,
+            `${dexKey}_${poolAddress}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/solidly-v3/solidly-v3-factory.ts

@@ -0,0 +1,73 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import FactoryABI from '../../abi/uniswap-v3/UniswapV3Factory.abi.json';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { LogDescription } from 'ethers/lib/utils';
+import { FactoryState } from './types';
+
+export type OnPoolCreatedCallback = ({
+  token0,
+  token1,
+  tickSpacing,
+}: {
+  token0: string;
+  token1: string;
+  tickSpacing: bigint;
+}) => Promise<void>;
+
+/*
+ * "Stateless" event subscriber in order to capture "PoolCreated" event on new pools created.
+ * State is present, but it's a placeholder to actually make the events reach handlers (if there's no previous state - `processBlockLogs` is not called)
+ */
+export class SolidlyV3Factory extends StatefulEventSubscriber<FactoryState> {
+  handlers: {
+    [event: string]: (event: any) => Promise<void>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    protected readonly factoryAddress: Address,
+    logger: Logger,
+    protected readonly onPoolCreated: OnPoolCreatedCallback,
+    mapKey: string = '',
+  ) {
+    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+
+    this.addressesSubscribed = [factoryAddress];
+
+    this.logDecoder = (log: Log) => this.factoryIface.parseLog(log);
+
+    this.handlers['PoolCreated'] = this.handleNewPool.bind(this);
+  }
+
+  generateState(): FactoryState {
+    return {};
+  }
+
+  protected async processLog(
+    _: DeepReadonly<FactoryState>,
+    log: Readonly<Log>,
+  ): Promise<FactoryState> {
+    const event = this.logDecoder(log);
+    if (event.name in this.handlers) {
+      await this.handlers[event.name](event);
+    }
+
+    return {};
+  }
+
+  async handleNewPool(event: LogDescription) {
+    const token0 = event.args.token0.toLowerCase();
+    const token1 = event.args.token1.toLowerCase();
+    const tickSpacing = BigInt(event.args.tickSpacing);
+
+    await this.onPoolCreated({ token0, token1, tickSpacing });
+  }
+}

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

@@ -0,0 +1,358 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface, Result } from '@ethersproject/abi';
+import { DummyDexHelper, IDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { SolidlyV3 } from './solidly-v3';
+import { MIN_SQRT_RATIO, MAX_SQRT_RATIO } from './constants';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Address } from '@paraswap/core';
+import SolidlyV3PoolABI from '../../abi/solidly-v3/SolidlyV3Pool.abi.json';
+
+/*
+  README
+  ======
+
+  This test script adds tests for SolidlyV3 general integration
+  with the DEX interface. The test cases below are example tests.
+  It is recommended to add tests which cover SolidlyV3 specific
+  logic.
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-integration.test.ts`
+
+  (This comment should be removed from the final implementation)
+*/
+
+const network = Network.MAINNET;
+const dexHelper = new DummyDexHelper(network);
+
+const WETH = Tokens[network]['WETH'];
+const USDC = Tokens[network]['USDC'];
+
+const amounts = [0n, 1n * BI_POWS[18], 2n * BI_POWS[18]];
+// Sell WETH to receive 1000 USDC, 2000 UDST, and 3000 USDC
+const amountsBuy = [
+  0n,
+  1000n * BI_POWS[6],
+  2000n * BI_POWS[6],
+  3000n * BI_POWS[6],
+];
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  amounts: bigint[],
+  funcName: string,
+  zeroForOne: boolean,
+  sqrtPriceLimitX96: bigint,
+  exactInput: boolean,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(funcName, [
+      zeroForOne,
+      exactInput ? amount.toString() : `-${amount.toString()}`,
+      sqrtPriceLimitX96.toString(),
+    ]),
+  }));
+}
+
+// We are only using this function to decode `quoteSwap` on SolidlyV3Pool. The output param we consider relevant
+// depends on `zeroForOne` and `exactInput`.
+function decodeReaderResult(
+  results: Result,
+  readerIface: Interface,
+  funcName: string,
+  zeroForOne: boolean,
+  exactInput: boolean,
+) {
+  return results.map(result => {
+    const parsed = readerIface.decodeFunctionResult(funcName, result);
+    // zeroForOne determines whether we want to get amount0 or amount1
+    let index;
+    if (zeroForOne == exactInput) {
+      index = 1;
+    } else {
+      index = 0;
+    }
+    return parsed[index]._hex[0] == '-'
+      ? BigInt(parsed[index]._hex.slice(1))
+      : BigInt(parsed[index]._hex);
+  });
+}
+
+async function checkOnChainPricing(
+  dexHelper: IDexHelper,
+  blockNumber: number,
+  poolAddress: string,
+  prices: bigint[],
+  tokenIn: Address,
+  tokenOut: Address,
+  tickSpacing: bigint,
+  _amounts: bigint[],
+  exactInput: boolean,
+) {
+  const readerIface = new Interface(SolidlyV3PoolABI);
+
+  const sum = prices.reduce((acc, curr) => (acc += curr), 0n);
+
+  if (sum === 0n) {
+    console.log(
+      `Prices were not calculated for tokenIn=${tokenIn}, tokenOut=${tokenOut}, tickSpacing=${tickSpacing.toString()}. Most likely price impact is too big for requested amount`,
+    );
+    return false;
+  }
+
+  const readerCallData = getReaderCalldata(
+    poolAddress,
+    readerIface,
+    _amounts.slice(1),
+    'quoteSwap',
+    tokenIn < tokenOut,
+    tokenIn < tokenOut
+      ? MIN_SQRT_RATIO + BigInt(1)
+      : MAX_SQRT_RATIO - BigInt(1),
+    exactInput,
+  );
+
+  let readerResult;
+  try {
+    readerResult = (
+      await dexHelper.multiContract.methods
+        .aggregate(readerCallData)
+        .call({}, blockNumber)
+    ).returnData;
+  } catch (e) {
+    console.log(
+      `Can not fetch on-chain pricing for tickSpacing ${tickSpacing}. It happens for low liquidity pools`,
+      e,
+    );
+    return false;
+  }
+
+  const expectedPrices = [0n].concat(
+    decodeReaderResult(
+      readerResult,
+      readerIface,
+      'quoteSwap',
+      tokenIn < tokenOut,
+      exactInput,
+    ),
+  );
+
+  console.log('EXPECTED PRICES: ', expectedPrices);
+
+  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;
+}
+
+async function testPricingOnNetwork(
+  solidlyV3: SolidlyV3,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await solidlyV3.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await solidlyV3.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (solidlyV3.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+}
+
+describe('SolidlyV3', function () {
+  const dexKey = 'SolidlyV3';
+  let blockNumber: number;
+  let solidlyV3: SolidlyV3;
+
+  beforeEach(async () => {
+    blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const solidlyV3 = new SolidlyV3(network, dexKey, dexHelper);
+  });
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    // TODO: Put here token Symbol to check against
+    // Don't forget to update relevant tokens in constant-e2e.ts
+    const srcTokenSymbol = 'WETH';
+    const destTokenSymbol = 'USDC';
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      solidlyV3 = new SolidlyV3(network, dexKey, dexHelper);
+      if (solidlyV3.initializePricing) {
+        await solidlyV3.initializePricing(blockNumber);
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      const pools = await solidlyV3.getPoolIdentifiers(
+        WETH,
+        USDC,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      console.log(`WETH <> USDC Pool Identifiers: `, pools);
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await solidlyV3.getPricesVolume(
+        WETH,
+        USDC,
+        amounts,
+        SwapSide.SELL,
+        blockNumber,
+        pools,
+      );
+      console.log(`WETH <> USDC Pool Prices: `, poolPrices);
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const tickSpacing =
+            solidlyV3.eventPools[price.poolIdentifier!]!.tickSpacing;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            blockNumber,
+            solidlyV3.eventPools[price.poolIdentifier!]!.poolAddress,
+            price.prices,
+            WETH.address,
+            USDC.address,
+            tickSpacing,
+            amounts,
+            true,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      const pools = await solidlyV3.getPoolIdentifiers(
+        WETH,
+        USDC,
+        SwapSide.BUY,
+        blockNumber,
+      );
+      console.log(`WETH <> USDC Pool Identifiers: `, pools);
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await solidlyV3.getPricesVolume(
+        WETH,
+        USDC,
+        amountsBuy,
+        SwapSide.BUY,
+        blockNumber,
+        pools,
+      );
+      console.log(`WETH <> USDC Pool Prices: `, poolPrices);
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, amountsBuy, SwapSide.BUY, dexKey);
+
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const tickSpacing =
+            solidlyV3.eventPools[price.poolIdentifier!]!.tickSpacing;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            blockNumber,
+            solidlyV3.eventPools[price.poolIdentifier!]!.poolAddress,
+            price.prices,
+            WETH.address,
+            USDC.address,
+            tickSpacing,
+            amountsBuy,
+            false,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const newSolidlyV3 = new SolidlyV3(network, dexKey, dexHelper);
+      // if (newSolidlyV3.updatePoolState) {
+      //   await newSolidlyV3.updatePoolState();
+      // }
+      const poolLiquidity = await newSolidlyV3.getTopPoolsForToken(
+        tokens[srcTokenSymbol].address,
+        10,
+      );
+      console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+      if (!newSolidlyV3.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][srcTokenSymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
+});