@paraswap/dex-lib 3.5.6-maverick-v2-7 → 3.6.0

package/src/dex/maverick-v2/maverick-v2-integration.test.ts

@@ -1,269 +0,0 @@
-/* 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 { MaverickV2 } from './maverick-v2';
-import {
-  checkPoolPrices,
-  checkPoolsLiquidity,
-  checkConstantPoolPrices,
-} from '../../../tests/utils';
-import { Tokens } from '../../../tests/constants-e2e';
-import { MaverickV2Data } from './types';
-import { ExchangePrices, PoolPrices } from '../../types';
-import MaverickV2QuoterABI from '../../abi/maverick-v2/MaverickV2Quoter.json';
-import { MaverickV2Config } from './config';
-import { AbiItem } from 'web3-utils';
-
-/*
-  README
-  ======
-
-  This test script adds tests for MaverickV2 general integration
-  with the DEX interface. The test cases below are example tests.
-  It is recommended to add tests which cover MaverickV2 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.BASE;
-const dexKey = 'MaverickV2';
-const dexHelper = new DummyDexHelper(network);
-
-function calculateSwap(
-  network: Network,
-  pool: PoolPrices<MaverickV2Data>,
-  blockNumber: number,
-  poolAddress: string,
-  srcToken: string,
-  side: SwapSide,
-  amount: bigint,
-) {
-  return new Promise(async (resolve, reject) => {
-    let quoterContract = new dexHelper.web3Provider.eth.Contract(
-      MaverickV2QuoterABI as AbiItem[],
-      MaverickV2Config[dexKey][network].quoterAddress,
-    );
-
-    await quoterContract.methods
-      .calculateSwap(
-        poolAddress,
-        amount,
-        pool.data.tokenA.toLowerCase() == srcToken.toLowerCase(),
-        side == SwapSide.BUY,
-        pool.data.tokenA.toLowerCase() == srcToken.toLowerCase()
-          ? 1000000n
-          : -1000000n,
-      )
-      .call({}, blockNumber, (err: any, result: any) => {
-        resolve(result);
-      });
-  });
-}
-
-async function checkOnChainPricing(
-  maverickV2: MaverickV2,
-  funcName: string,
-  blockNumber: number,
-  pools: ExchangePrices<MaverickV2Data>,
-  amounts: bigint[],
-  side: SwapSide,
-  srcToken: string,
-) {
-  await Promise.all(
-    pools.map(async pool => {
-      const poolAddress = pool.data.pool;
-
-      const results = await Promise.all(
-        amounts.slice(1).map(async amount => {
-          return calculateSwap(
-            network,
-            pool,
-            blockNumber,
-            poolAddress,
-            srcToken,
-            side,
-            amount,
-          );
-        }),
-      );
-
-      const expectedPrices = [0n].concat(
-        results.map((result: any) =>
-          BigInt(side == SwapSide.SELL ? result.amountOut : result.amountIn),
-        ),
-      );
-
-      expect(pool.prices).toEqual(expectedPrices);
-    }),
-  );
-}
-
-async function testPricingOnNetwork(
-  maverickV2: MaverickV2,
-  network: Network,
-  dexKey: string,
-  blockNumber: number,
-  srcTokenSymbol: string,
-  destTokenSymbol: string,
-  side: SwapSide,
-  amounts: bigint[],
-  funcNameToCheck: string,
-) {
-  const networkTokens = Tokens[network];
-  const pools = await maverickV2.getPoolIdentifiers(
-    networkTokens[srcTokenSymbol],
-    networkTokens[destTokenSymbol],
-    side,
-    blockNumber,
-  );
-  console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
-    pools,
-  );
-
-  expect(pools.length).toBeGreaterThan(0);
-
-  const poolPrices = await maverickV2.getPricesVolume(
-    networkTokens[srcTokenSymbol],
-    networkTokens[destTokenSymbol],
-    amounts,
-    side,
-    blockNumber,
-    pools,
-  );
-  console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
-    poolPrices,
-  );
-
-  expect(poolPrices).not.toBeNull();
-  if (maverickV2.hasConstantPriceLargeAmounts) {
-    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
-  } else {
-    checkPoolPrices(poolPrices!, amounts, side, dexKey);
-  }
-
-  // Check if onchain pricing equals to calculated ones
-  await checkOnChainPricing(
-    maverickV2,
-    funcNameToCheck,
-    blockNumber,
-    poolPrices!,
-    amounts,
-    side,
-    Tokens[network]['DAI'].address,
-  );
-}
-
-describe('MaverickV2', function () {
-  const dexKey = 'MaverickV2';
-  let blockNumber: number;
-  let maverickV2: MaverickV2;
-
-  describe('Mainnet', () => {
-    const network = Network.BASE;
-    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 = 'DAI';
-    const destTokenSymbol = 'USDC';
-
-    const amountsForSell = [
-      0n,
-      1n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      2n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      3n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      4n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      5n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      6n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      7n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      8n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      9n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      10n * BI_POWS[tokens[srcTokenSymbol].decimals],
-    ];
-
-    const amountsForBuy = [
-      0n,
-      1n * BI_POWS[tokens[destTokenSymbol].decimals],
-      2n * BI_POWS[tokens[destTokenSymbol].decimals],
-      3n * BI_POWS[tokens[destTokenSymbol].decimals],
-      4n * BI_POWS[tokens[destTokenSymbol].decimals],
-      5n * BI_POWS[tokens[destTokenSymbol].decimals],
-      6n * BI_POWS[tokens[destTokenSymbol].decimals],
-      7n * BI_POWS[tokens[destTokenSymbol].decimals],
-      8n * BI_POWS[tokens[destTokenSymbol].decimals],
-      9n * BI_POWS[tokens[destTokenSymbol].decimals],
-      10n * BI_POWS[tokens[destTokenSymbol].decimals],
-    ];
-
-    beforeAll(async () => {
-      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      maverickV2 = new MaverickV2(network, dexKey, dexHelper);
-      if (maverickV2.initializePricing) {
-        await maverickV2.initializePricing(blockNumber);
-      }
-    });
-
-    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-      await testPricingOnNetwork(
-        maverickV2,
-        network,
-        dexKey,
-        blockNumber,
-        srcTokenSymbol,
-        destTokenSymbol,
-        SwapSide.SELL,
-        amountsForSell,
-        'calculatePrice', // TODO: Put here proper function name to check pricing
-      );
-    });
-
-    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-      await testPricingOnNetwork(
-        maverickV2,
-        network,
-        dexKey,
-        blockNumber,
-        srcTokenSymbol,
-        destTokenSymbol,
-        SwapSide.BUY,
-        amountsForBuy,
-        'calculatePrice', // TODO: Put here proper function name to check pricing
-      );
-    });
-
-    it('getTopPoolsForToken', async function () {
-      // We have to check without calling initializePricing, because
-      // pool-tracker is not calling that function
-      const newMaverickV2 = new MaverickV2(network, dexKey, dexHelper);
-      if (newMaverickV2.updatePoolState) {
-        await newMaverickV2.updatePoolState();
-      }
-      const poolLiquidity = await newMaverickV2.getTopPoolsForToken(
-        tokens[srcTokenSymbol].address,
-        10,
-      );
-      console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
-
-      if (!newMaverickV2.hasConstantPriceLargeAmounts) {
-        checkPoolsLiquidity(
-          poolLiquidity,
-          tokens[srcTokenSymbol].address,
-          dexKey,
-        );
-      }
-    });
-  });
-});

package/src/dex/maverick-v2/maverick-v2-pool.ts

@@ -1,276 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { DeepReadonly } from 'ts-essentials';
-import { Address, BlockHeader, Log, Logger, Token } from '../../types';
-import { catchParseLogError } from '../../utils';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { PoolState } from './types';
-import MaverickV2PoolABI from '../../abi/maverick-v2/MaverickV2Pool.json';
-import MaverickV2PoolLensABI from '../../abi/maverick-v2/MaverickV2PoolLens.json';
-import { AbiItem } from 'web3-utils';
-import { Contract } from 'web3-eth-contract';
-import { MaverickPoolMath } from './maverick-math/maverick-pool-math';
-import _ from 'lodash';
-``;
-export class MaverickV2EventPool extends StatefulEventSubscriber<PoolState> {
-  handlers: {
-    [event: string]: (
-      event: any,
-      state: DeepReadonly<PoolState>,
-      log: Readonly<Log>,
-      blockHeader: BlockHeader,
-    ) => DeepReadonly<PoolState> | null;
-  } = {};
-
-  poolContract: Contract;
-  poolLensContract: Contract;
-
-  logDecoder: (log: Log) => any;
-
-  addressesSubscribed: string[];
-
-  poolMath: MaverickPoolMath;
-
-  constructor(
-    readonly parentName: string,
-    protected network: number,
-    protected dexHelper: IDexHelper,
-    logger: Logger,
-    public tokenA: Token,
-    public tokenB: Token,
-    public feeAIn: number,
-    public feeBIn: number,
-    public tickSpacing: number,
-    public protocolFeeRatio: number,
-    public lookback: number,
-    public activeTick: number,
-    public address: Address,
-    public poolLensAddress: Address,
-    protected maverickV2Iface = new Interface(MaverickV2PoolABI), // TODO: add any additional params required for event subscriber
-  ) {
-    const name = `${parentName}-${tokenA.symbol}-${tokenB.symbol}-${feeAIn}-${feeBIn}-${tickSpacing}-${protocolFeeRatio}-${lookback}-${activeTick}`;
-    super(parentName, name, dexHelper, logger);
-
-    // TODO: make logDecoder decode logs that
-    this.logDecoder = (log: Log) => this.maverickV2Iface.parseLog(log);
-    this.addressesSubscribed = [address];
-
-    // Add handlers
-    this.handlers['PoolAddLiquidity'] = this.handleAddLiquidityEvent.bind(this);
-    this.handlers['PoolRemoveLiquidity'] =
-      this.handleRemoveLiquidityEvent.bind(this);
-    this.handlers['PoolSwap'] = this.handleSwapEvent.bind(this);
-
-    this.poolMath = new MaverickPoolMath(
-      BigInt(feeAIn),
-      BigInt(feeBIn),
-      BigInt(lookback),
-      BigInt(tickSpacing),
-      BigInt(protocolFeeRatio),
-      BigInt(activeTick),
-      BigInt(tokenA.decimals),
-      BigInt(tokenB.decimals),
-    );
-
-    this.poolContract = new this.dexHelper.web3Provider.eth.Contract(
-      MaverickV2PoolABI as AbiItem[],
-      this.address,
-    );
-
-    this.poolLensContract = new this.dexHelper.web3Provider.eth.Contract(
-      MaverickV2PoolLensABI as AbiItem[],
-      this.poolLensAddress,
-    );
-  }
-
-  /**
-   * The function is called every time any of the subscribed
-   * addresses release log. The function accepts the current
-   * state, updates the state according to the log, and returns
-   * the updated state.
-   * @param state - Current state of event subscriber
-   * @param log - Log released by one of the subscribed addresses
-   * @returns Updates state of the event subscriber after the log
-   */
-  protected processLog(
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-    blockHeader: Readonly<BlockHeader>,
-  ): DeepReadonly<PoolState> | null {
-    try {
-      const event = this.logDecoder(log);
-      if (event.name in this.handlers) {
-        return this.handlers[event.name](event, state, log, blockHeader);
-      }
-    } catch (e) {
-      catchParseLogError(e, this.logger);
-    }
-
-    return null;
-  }
-
-  /**
-   * The function generates state using on-chain calls. This
-   * function is called to regenerate state if the event based
-   * system fails to fetch events and the local state is no
-   * more correct.
-   * @param blockNumber - Blocknumber for which the state should
-   * should be generated
-   * @returns state of the event subscriber at blocknumber
-   */
-
-  async generateState(blockNumber: number): Promise<DeepReadonly<PoolState>> {
-    try {
-      const poolContractState = await this.poolContract.methods
-        .getState()
-        .call({}, blockNumber);
-
-      const poolState: PoolState = {
-        activeTick: BigInt(poolContractState.activeTick),
-        binCounter: BigInt(poolContractState.binCounter),
-        reserveA: BigInt(poolContractState.reserveA),
-        reserveB: BigInt(poolContractState.reserveB),
-        lastTwaD8: BigInt(poolContractState.lastTwaD8),
-        lastLogPriceD8: BigInt(poolContractState.lastLogPriceD8),
-        lastTimestamp: BigInt(poolContractState.lastTimestamp),
-        bins: {},
-        ticks: {},
-      };
-
-      for (let i = 0n; i < poolState.binCounter / 5000n + 1n; i++) {
-        const poolLensState = await this.poolLensContract.methods[
-          'getFullPoolState'
-        ](this.address, i * 5000n, (i + 1n) * 5000n).call({}, blockNumber);
-
-        poolLensState.binStateMapping.forEach((bin: any, i: number) => {
-          if (i == 0) return;
-          const tick = poolLensState.tickStateMapping[i];
-          poolState.bins[i.toString()] = {
-            mergeBinBalance: BigInt(bin.mergeBinBalance),
-            mergeId: BigInt(bin.mergeId),
-            totalSupply: BigInt(bin.totalSupply),
-            kind: BigInt(bin.kind),
-            tick: BigInt(bin.tick),
-            tickBalance: BigInt(bin.tickBalance),
-          };
-          poolState.ticks[bin.tick.toString()] = {
-            reserveA: BigInt(tick.reserveA),
-            reserveB: BigInt(tick.reserveB),
-            totalSupply: BigInt(tick.totalSupply),
-            binIdsByTick: {},
-          };
-          tick.binIdsByTick.forEach((id: any, i: number) => {
-            if (id != 0n) {
-              poolState.ticks[bin.tick.toString()].binIdsByTick[i.toString()] =
-                BigInt(id);
-            }
-          });
-        });
-      }
-      return poolState;
-    } catch {
-      return {
-        activeTick: BigInt(0),
-        binCounter: BigInt(0),
-        reserveA: BigInt(0),
-        reserveB: BigInt(0),
-        lastTwaD8: BigInt(0),
-        lastLogPriceD8: BigInt(0),
-        lastTimestamp: BigInt(0),
-        bins: {},
-        ticks: {},
-      };
-    }
-  }
-
-  handleRemoveLiquidityEvent(
-    event: any,
-    state: PoolState,
-    log: Log,
-    blockHeader: BlockHeader,
-  ) {
-    const blockTimestamp = BigInt(blockHeader.timestamp);
-    this.poolMath.removeLiquidity(state, blockTimestamp, {
-      binIds: event.args.params.binIds.map((id: any) => BigInt(id)),
-      amounts: event.args.params.amounts.map((amount: any) => BigInt(amount)),
-    });
-    return state;
-  }
-
-  handleAddLiquidityEvent(
-    event: any,
-    state: PoolState,
-    log: Log,
-    blockHeader: BlockHeader,
-  ) {
-    const blockTimestamp = BigInt(blockHeader.timestamp);
-    this.poolMath.addLiquidity(state, blockTimestamp, {
-      ticks: event.args.params.ticks.map((amount: any) => BigInt(amount)),
-      amounts: event.args.params.amounts.map((amount: any) => BigInt(amount)),
-      kind: BigInt(event.args.params.kind),
-    });
-    return state;
-  }
-
-  handleSwapEvent(
-    event: any,
-    state: PoolState,
-    log: Log,
-    blockHeader: BlockHeader,
-  ) {
-    const blockTimestamp = BigInt(blockHeader.timestamp);
-    this.poolMath.swap(
-      state,
-      blockTimestamp,
-      BigInt(event.args.params.amount),
-      event.args.params.tokenAIn,
-      event.args.params.exactOutput,
-      event.args.params.tickLimit,
-    );
-    return state;
-  }
-
-  swap(
-    amount: bigint,
-    from: Token,
-    to: Token,
-    side: boolean,
-  ): [bigint, number] {
-    try {
-      const tempState = _.cloneDeep(this.state!);
-
-      const preActiveTick = tempState.activeTick;
-
-      const output = this.poolMath.estimateSwap(
-        tempState,
-        amount,
-        from.address.toLowerCase() == this.tokenA.address.toLowerCase(),
-        side,
-        from.address.toLowerCase() == this.tokenA.address.toLowerCase()
-          ? tempState.activeTick + 20n
-          : tempState.activeTick - 20n,
-      );
-
-      if (output[0] == 0n && output[1] == 0n) {
-        this.logger.trace(
-          `Reached max swap iteration calculation for address=${this.address} amount=${amount}, from=${from.address}, to=${to.address}, side=${side}`,
-        );
-        return [0n, 0];
-      }
-
-      const postActiveTick = tempState.activeTick;
-      const tickDiff = Math.abs(Number(postActiveTick) - Number(preActiveTick));
-
-      return [
-        side ? output[0] : output[1],
-        // Tick calculation must be started from 1 to account at least one tick
-        tickDiff + 1,
-      ];
-    } catch (e) {
-      this.logger.debug(
-        `Failed to calculate swap for address=${this.address} amount=${amount}, from=${from.address}, to=${to.address}, side=${side} math: ${e}`,
-      );
-      return [0n, 0];
-    }
-  }
-}