@paraswap/dex-lib 3.8.2 → 3.8.3-integral-dex

package/src/dex/integral/integral-integration.test.ts

@@ -0,0 +1,221 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { Integral } from './integral';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Token } from '../../types';
+import { IntegralConfig } from './config';
+import IntegralRelayerABI from '../../abi/integral/relayer.json';
+import { Interface } from '@ethersproject/abi';
+import { uint256ToBigInt } from '../../lib/decoders';
+import { MultiCallParams } from '../../lib/multi-wrapper';
+
+jest.setTimeout(50 * 1000);
+const network = Network.MAINNET;
+const testDatas: {
+  tokenA: Token;
+  tokenB: Token;
+  block: number;
+  data: number[];
+}[] = [
+  {
+    tokenA: { symbol: 'USDC' } as Token,
+    tokenB: { symbol: 'USDT' } as Token,
+    block: 19608294,
+    data: [
+      0, 5100, 10200, 15300, 20400, 25500, 30600, 35700, 40800, 45900, 51000,
+    ],
+  },
+  {
+    tokenA: { symbol: 'USDT' } as Token,
+    tokenB: { symbol: 'WETH' } as Token,
+    block: 19831195,
+    data: [0, 1.7, 3.4, 5.1, 6.8, 8.5, 10.2, 11.9, 13.6, 15.3, 17],
+  },
+];
+initializeTokens();
+
+const dexHelper = new DummyDexHelper(network);
+const dexKey = 'Integral';
+
+function initializeTokens() {
+  for (const [i, testData] of testDatas.entries()) {
+    const tokenA = Tokens[network][testData.tokenA.symbol!];
+    const tokenB = Tokens[network][testData.tokenB.symbol!];
+    tokenA.symbol = testData.tokenA.symbol;
+    tokenB.symbol = testData.tokenB.symbol;
+    testDatas[i].tokenA = tokenA;
+    testDatas[i].tokenB = tokenB;
+  }
+}
+
+function initializeAmounts(token: Token, units: number[]) {
+  const precision = 10 ** 18;
+  return units.map(
+    unit =>
+      (BigInt(unit * precision) * BI_POWS[token.decimals]) / BigInt(precision),
+  );
+}
+
+async function checkOnChainPricing(
+  relayerAddress: string,
+  funcName: string,
+  blockNumber: number,
+  prices: bigint[],
+  TokenA: Token,
+  TokenB: Token,
+  expectedAmounts: bigint[],
+) {
+  const relayerInterface = new Interface(IntegralRelayerABI);
+  const callData = expectedAmounts
+    .slice(1)
+    .map<MultiCallParams<bigint>>(amount => ({
+      target: relayerAddress,
+      callData: relayerInterface.encodeFunctionData(funcName, [
+        TokenA.address,
+        TokenB.address,
+        amount,
+      ]),
+      decodeFunction: uint256ToBigInt,
+    }));
+  const results = await dexHelper.multiWrapper.tryAggregate(
+    false,
+    callData,
+    blockNumber,
+    dexHelper.multiWrapper.defaultBatchSize,
+    false,
+  );
+
+  const expectedPrices = [0n].concat(results.map(result => result.returnData));
+  expect(prices).toEqual(expectedPrices);
+}
+
+for (const { tokenA, tokenB, data, block } of testDatas) {
+  describe(`Integral Pool ${tokenB.symbol}-${tokenA.symbol}`, function () {
+    let integral: Integral;
+
+    beforeAll(async () => {
+      integral = new Integral(network, dexKey, dexHelper);
+      await integral.initializePricing(block);
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL [${tokenB.symbol}, ${tokenA.symbol}]`, async function () {
+      const amounts = initializeAmounts(tokenB, data);
+      const pools = await integral.getPoolIdentifiers(
+        tokenB,
+        tokenA,
+        SwapSide.SELL,
+        block,
+      );
+      console.log(
+        `${tokenA.symbol} <> ${tokenB.symbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await integral.getPricesVolume(
+        tokenB,
+        tokenA,
+        amounts,
+        SwapSide.SELL,
+        block,
+        pools,
+      );
+      console.log(
+        `${tokenA.symbol} <> ${tokenB.symbol} Pool Prices, SELL: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      if (integral.hasConstantPriceLargeAmounts) {
+        checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+      } else {
+        checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+      }
+
+      // Check if onchain pricing equals to calculated ones
+      await checkOnChainPricing(
+        IntegralConfig[dexKey][network].relayerAddress,
+        'quoteSell',
+        block,
+        poolPrices![0].prices,
+        tokenB,
+        tokenA,
+        amounts,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY [${tokenA.symbol}, ${tokenB.symbol}]`, async function () {
+      const amounts = initializeAmounts(tokenB, data);
+      const pools = await integral.getPoolIdentifiers(
+        tokenA,
+        tokenB,
+        SwapSide.BUY,
+        block,
+      );
+      console.log(
+        `${tokenA.symbol} <> ${tokenB.symbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await integral.getPricesVolume(
+        tokenA,
+        tokenB,
+        amounts,
+        SwapSide.BUY,
+        block,
+        pools,
+      );
+      console.log(
+        `${tokenA.symbol} <> ${tokenB.symbol} Pool Prices, Buy: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      if (integral.hasConstantPriceLargeAmounts) {
+        checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+      } else {
+        checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+      }
+
+      // Check if onchain pricing equals to calculated ones
+      await checkOnChainPricing(
+        IntegralConfig[dexKey][network].relayerAddress,
+        'quoteBuy',
+        block,
+        poolPrices![0].prices,
+        tokenA,
+        tokenB,
+        amounts,
+      );
+    });
+  });
+}
+
+describe('Integral Top Pools', function () {
+  const integral = new Integral(network, dexKey, dexHelper);
+  const { tokenA } = testDatas[0];
+  it(`getTopPoolsForToken [${tokenA.symbol}]`, async function () {
+    const poolLiquidity = await integral.getTopPoolsForToken(
+      tokenA.address,
+      10,
+    );
+    console.log(`${tokenA.symbol} Top Pools:`, poolLiquidity);
+
+    if (!integral.hasConstantPriceLargeAmounts) {
+      checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+    }
+  });
+});

package/src/dex/integral/integral-pool.ts

@@ -0,0 +1,198 @@
+import _ from 'lodash';
+import { Interface } from '@ethersproject/abi';
+import { LogDescription } from 'ethers/lib/utils';
+import { AsyncOrSync } from 'ts-essentials';
+import { BlockHeader, Log, Logger } from '../../types';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { PoolState } from './types';
+import IntegralPoolABI from '../../abi/integral/pool.json';
+import IntegralOracleABI from '../../abi/integral/oracle.json';
+import UniswapV3PoolABI from '../../abi/uniswap-v3/UniswapV3Pool.abi.json';
+import { Address } from '../../types';
+import { MultiCallParams } from '../../lib/multi-wrapper';
+import {
+  addressDecode,
+  uint256ToBigInt,
+  uint8ToNumber,
+} from '../../lib/decoders';
+import { AbiItem } from 'web3-utils';
+import { BigNumber } from 'ethers';
+
+export class IntegralEventPool extends StatefulEventSubscriber<PoolState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      pool: PoolState,
+      blockHeader: Readonly<BlockHeader>,
+    ) => AsyncOrSync<PoolState>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  addressesSubscribed: string[];
+
+  readonly poolAddress: Address;
+  readonly token0: Address;
+  readonly token1: Address;
+
+  constructor(
+    public parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    poolAddress: Address,
+    token0: Address,
+    token1: Address,
+    logger: Logger,
+    protected poolIface = new Interface(IntegralPoolABI),
+  ) {
+    super(parentName, `${token0}_${token1}`, dexHelper, logger);
+    this.token0 = token0.toLowerCase();
+    this.token1 = token1.toLowerCase();
+    this.poolAddress = poolAddress.toLowerCase();
+
+    this.logDecoder = (log: Log) => this.poolIface.parseLog(log);
+    this.addressesSubscribed = [this.poolAddress];
+    this.handlers['SetSwapFee'] = this.handleSetSwapFee.bind(this);
+    this.handlers['SetMintFee'] = this.handleSetMintFee.bind(this);
+    this.handlers['SetBurnFee'] = this.handleSetBurnFee.bind(this);
+  }
+
+  /**
+   * 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 async processLog(
+    state: PoolState,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): Promise<PoolState | null> {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return await this.handlers[event.name](event, state, blockHeader);
+      }
+      return state;
+    } catch (e) {
+      this.logger.error(
+        `Error_${this.parentName}_processLog could not parse the log with topic ${log.topics}:`,
+        e,
+      );
+      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<Readonly<PoolState>> {
+    const state = {} as PoolState;
+    const pool = new this.dexHelper.web3Provider.eth.Contract(
+      IntegralPoolABI as AbiItem[],
+      this.poolAddress,
+    );
+    const poolInfoCallDatas: MultiCallParams<string | bigint>[] = [
+      {
+        target: this.poolAddress,
+        callData: pool.methods.oracle().encodeABI(),
+        decodeFunction: addressDecode,
+      },
+      {
+        target: this.poolAddress,
+        callData: pool.methods.mintFee().encodeABI(),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.poolAddress,
+        callData: pool.methods.burnFee().encodeABI(),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.poolAddress,
+        callData: pool.methods.swapFee().encodeABI(),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+    const poolInfos = await this.dexHelper.multiWrapper.aggregate<
+      string | bigint
+    >(poolInfoCallDatas, blockNumber);
+    const oracleAddress = poolInfos[0].toString();
+
+    state.mintFee = BigInt(poolInfos[1]);
+    state.burnFee = BigInt(poolInfos[2]);
+    state.swapFee = BigInt(poolInfos[3]);
+    state.oracle = oracleAddress;
+
+    const historyState = this.getStaleState();
+    if (!historyState) {
+      const oracle = new this.dexHelper.web3Provider.eth.Contract(
+        IntegralOracleABI as AbiItem[],
+        oracleAddress,
+      );
+      const oracleInfosCallDatas: MultiCallParams<number | string>[] = [
+        {
+          target: oracleAddress,
+          callData: oracle.methods.xDecimals().encodeABI(),
+          decodeFunction: uint8ToNumber,
+        },
+        {
+          target: oracleAddress,
+          callData: oracle.methods.yDecimals().encodeABI(),
+          decodeFunction: uint8ToNumber,
+        },
+        {
+          target: oracleAddress,
+          callData: oracle.methods.uniswapPair().encodeABI(),
+          decodeFunction: addressDecode,
+        },
+      ];
+      const oracleInfos = await this.dexHelper.multiWrapper.aggregate<
+        number | string
+      >(oracleInfosCallDatas, blockNumber);
+
+      state.uniswapPool = oracleInfos[2].toString();
+      state.decimals0 = Number(oracleInfos[0]);
+      state.decimals1 = Number(oracleInfos[1]);
+
+      const uniswapPool = new this.dexHelper.web3Provider.eth.Contract(
+        UniswapV3PoolABI as AbiItem[],
+        state.uniswapPool,
+      );
+      const fee = await uniswapPool.methods.fee().call(undefined, blockNumber);
+      state.uniswapPoolFee = BigInt(fee);
+    } else {
+      state.uniswapPool = historyState.uniswapPool;
+      state.decimals0 = historyState.decimals0;
+      state.decimals1 = historyState.decimals1;
+      state.uniswapPoolFee = historyState.uniswapPoolFee;
+    }
+
+    return state;
+  }
+
+  handleSetSwapFee(event: LogDescription, pool: PoolState) {
+    pool.swapFee = BigInt(BigNumber.from(event.args.fee).toString());
+    return pool;
+  }
+
+  handleSetMintFee(event: LogDescription, pool: PoolState) {
+    pool.mintFee = BigInt(BigNumber.from(event.args.fee).toString());
+    return pool;
+  }
+
+  handleSetBurnFee(event: LogDescription, pool: PoolState) {
+    pool.burnFee = BigInt(BigNumber.from(event.args.fee).toString());
+    return pool;
+  }
+}

package/src/dex/integral/integral-pricing.ts

@@ -0,0 +1,190 @@
+import { Interface } from '@ethersproject/abi';
+import { IDexHelper } from '../../dex-helper';
+import { Address, Logger } from '../../types';
+import { UniswapV3EventPool } from '../uniswap-v3/uniswap-v3-pool';
+import { UniswapV3Config } from '../uniswap-v3/config';
+import UniswapV3StateMulticallABI from '../../abi/uniswap-v3/UniswapV3StateMulticall.abi.json';
+import { Network } from '../../constants';
+import { AbiItem } from 'web3-utils';
+import {
+  DecodedStateMultiCallResultWithRelativeBitmaps,
+  OracleObservation,
+  PoolState,
+} from '../uniswap-v3/types';
+import {
+  _reduceTickBitmap,
+  _reduceTicks,
+} from '../uniswap-v3/contract-math/utils';
+import { bigIntify } from '../../utils';
+import { TickBitMap } from '../uniswap-v3/contract-math/TickBitMap';
+import { Observation } from './types';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { BytesLike, ethers } from 'ethers';
+import { extractSuccessAndValue } from '../../lib/decoders';
+
+export function decodeStateMultiCallResultWithObservation(
+  result: MultiResult<BytesLike> | BytesLike,
+): Observation {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  if (!isSuccess || toDecode === '0x')
+    throw new Error(
+      `decodeStateMultiCallResultWithRelativeBitmaps failed to get decodable result: ${result}`,
+    );
+
+  const decoded = ethers.utils.defaultAbiCoder.decode(
+    [
+      `
+      tuple(
+        uint32 blockTimestamp,
+        int56 tickCumulative,
+        uint160 secondsPerLiquidityCumulativeX128,
+        bool initialized,
+      )
+    `,
+    ],
+    toDecode,
+  )[0];
+  return decoded as Observation;
+}
+
+export class IntegralPricing extends UniswapV3EventPool {
+  private readonly providedPoolAddress: Address;
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    erc20Interface: Interface,
+    poolAddress: Address,
+    token0: Address,
+    token1: Address,
+    feeCode: bigint,
+    logger: Logger,
+    network: Network,
+    mapKey: string = '',
+  ) {
+    const uniswapConfig = UniswapV3Config['UniswapV3'][network];
+    const stateMultiContract = new dexHelper.web3Provider.eth.Contract(
+      uniswapConfig.stateMultiCallAbi !== undefined
+        ? uniswapConfig.stateMultiCallAbi
+        : (UniswapV3StateMulticallABI as AbiItem[]),
+      uniswapConfig.stateMulticall,
+    );
+    super(
+      dexHelper,
+      parentName,
+      stateMultiContract,
+      undefined,
+      erc20Interface,
+      uniswapConfig.factory,
+      feeCode,
+      token0,
+      token1,
+      logger,
+      mapKey,
+      uniswapConfig.initHash,
+    );
+    this.providedPoolAddress = poolAddress;
+  }
+
+  get poolAddress() {
+    return this.providedPoolAddress;
+  }
+
+  set poolAddress(_address: Address) {}
+
+  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
+    const callData = this._getStateRequestCallData();
+
+    const [resBalance0, resBalance1, resState] =
+      await this.dexHelper.multiWrapper.tryAggregate<
+        bigint | DecodedStateMultiCallResultWithRelativeBitmaps
+      >(
+        false,
+        callData,
+        blockNumber,
+        this.dexHelper.multiWrapper.defaultBatchSize,
+        false,
+      );
+
+    if (!resState.success) throw new Error('Pool does not exist');
+
+    const [balance0, balance1, _state] = [
+      resBalance0.returnData,
+      resBalance1.returnData,
+      resState.returnData,
+    ] as [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmaps];
+
+    const observationsCallData = [
+      ...Array(_state.slot0.observationCardinality),
+    ].map((_, i) => {
+      return {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('observations', [i]),
+        decodeFunction: decodeStateMultiCallResultWithObservation,
+      };
+    });
+
+    const resObservations =
+      await this.dexHelper.multiWrapper.tryAggregate<Observation>(
+        false,
+        observationsCallData,
+        blockNumber,
+        13107,
+        false,
+      );
+    const observations = resObservations.reduce((memo, obs, i) => {
+      memo[i] = {
+        blockTimestamp: BigInt(obs.returnData.blockTimestamp),
+        tickCumulative: BigInt(obs.returnData.tickCumulative.toString()),
+        secondsPerLiquidityCumulativeX128: BigInt(
+          obs.returnData.secondsPerLiquidityCumulativeX128.toString(),
+        ),
+        initialized: obs.returnData.initialized,
+      };
+      return memo;
+    }, {} as { [index: number]: OracleObservation });
+
+    const tickBitmap = {};
+    const ticks = {};
+
+    _reduceTickBitmap(tickBitmap, _state.tickBitmap);
+    _reduceTicks(ticks, _state.ticks);
+
+    const currentTick = bigIntify(_state.slot0.tick);
+    const tickSpacing = bigIntify(_state.tickSpacing);
+
+    const startTickBitmap = TickBitMap.position(currentTick / tickSpacing)[0];
+    const requestedRange = this.getBitmapRangeToRequest();
+
+    return {
+      pool: _state.pool,
+      blockTimestamp: bigIntify(_state.blockTimestamp),
+      slot0: {
+        sqrtPriceX96: bigIntify(_state.slot0.sqrtPriceX96),
+        tick: currentTick,
+        observationIndex: +_state.slot0.observationIndex,
+        observationCardinality: +_state.slot0.observationCardinality,
+        observationCardinalityNext: +_state.slot0.observationCardinalityNext,
+        feeProtocol: bigIntify(_state.slot0.feeProtocol),
+      },
+      liquidity: bigIntify(_state.liquidity),
+      fee: this.feeCode,
+      tickSpacing,
+      maxLiquidityPerTick: bigIntify(_state.maxLiquidityPerTick),
+      tickBitmap,
+      ticks,
+      observations,
+      isValid: true,
+      startTickBitmap,
+      lowestKnownTick:
+        (BigInt.asIntN(24, startTickBitmap - requestedRange) << 8n) *
+        tickSpacing,
+      highestKnownTick:
+        ((BigInt.asIntN(24, startTickBitmap + requestedRange) << 8n) +
+          BigInt.asIntN(24, 255n)) *
+        tickSpacing,
+      balance0,
+      balance1,
+    };
+  }
+}