@paraswap/dex-lib 3.4.1 → 3.4.2-idle

package/src/dex/idle-dao/idle-dao-e2e.test.ts

@@ -0,0 +1,113 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } 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,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol} - ${tokenAAmount}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+
+            it(`${tokenBSymbol} -> ${tokenASymbol} - ${tokenBAmount}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('IdleDao E2E', () => {
+  const dexKey = 'IdleDao';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const tests = [
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'AA_wstETH',
+        tokenAAmount: '1000000000000000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDC',
+        tokenBSymbol: 'AA_idle_cpPOR-USDC',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDT',
+        tokenBSymbol: 'BB_idle_cpFAS-USDT',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'WETH',
+        tokenBSymbol: 'BB_Re7WETH',
+        tokenAAmount: '100000000000000',
+        tokenBAmount: '100000000000000',
+      },
+    ];
+
+    tests.forEach(testData => {
+      testForNetwork(
+        network,
+        dexKey,
+        testData.tokenASymbol,
+        testData.tokenBSymbol,
+        testData.tokenAAmount,
+        testData.tokenBAmount,
+      );
+    });
+  });
+});

package/src/dex/idle-dao/idle-dao-events.test.ts

@@ -0,0 +1,133 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { IdleDao } from './idle-dao';
+import { IdleDaoEventPool } from './idle-dao-pool';
+import { Network } from '../../constants';
+import { Address, Logger } from '../../types';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolState, IdleToken } from './types';
+
+jest.setTimeout(50 * 1000);
+
+async function fetchPoolState(
+  idleDaoPool: IdleDaoEventPool,
+  blockNumber: number,
+  poolAddress: string,
+  logger: Logger,
+): Promise<PoolState> {
+  const state = await idleDaoPool.generateState(blockNumber);
+  return state;
+}
+
+type EventMappings = Record<string, number[]>;
+
+describe('IdleDao EventPool Mainnet', function () {
+  const dexKey = 'IdleDao';
+  let latestBlockNumber: number;
+  const network = Network.MAINNET;
+  let tokensList: Record<string, IdleToken>;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  const idleDao: IdleDao = new IdleDao(network, dexKey, dexHelper);
+
+  beforeAll(async () => {
+    latestBlockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    await idleDao.initializePricing(latestBlockNumber);
+    tokensList = await idleDao.getTokensList(latestBlockNumber);
+  });
+
+  // poolAddress -> EventMappings
+  const eventsToTest: Record<
+    Address,
+    { blockNumber: number; events: EventMappings }
+  > = {
+    // BB_dUSDCV3
+    '0x2a84a042db06222c486bcb815e961f26599d0df6': {
+      blockNumber: 19676846,
+      events: {
+        Transfer: [
+          19676846, // DepositAA
+          19676851, // DepositBB
+          19681374, // Harvest
+          19681547, // WithdrawBB
+          20031918, // Harvest
+          20036646,
+        ],
+      },
+    },
+    // BB_clearpool_fasanara_USDT
+    '0x3eb6318b8d9f362a0e1d99f6032edb1c4c602500': {
+      blockNumber: 18341913,
+      events: {
+        Transfer: [
+          18341913, // DepositBB
+          18357425, // WithdrawBB
+          18646128, // DepositBB
+          18804244, // WithdrawAA
+          18908679, // Harvest
+          20036646,
+        ],
+      },
+    },
+    '0x7b713b1cb6eafd4061064581579ffccf7df21545': {
+      blockNumber: 18985108,
+      events: {
+        Transfer: [
+          18985108, // DepositBB
+          18997082, // WithdrawBB
+          19013537, // Harvest
+          19346397, // DepositAA
+          20036646,
+        ],
+      },
+    },
+  };
+
+  Object.entries(eventsToTest).forEach(
+    ([poolAddress, { blockNumber, events }]: [
+      string,
+      { blockNumber: number; events: EventMappings },
+    ]) => {
+      describe(`Events for ${poolAddress}`, () => {
+        let idleDaoPool: IdleDaoEventPool | null;
+
+        it(`idleDaoPool for ${network} - ${poolAddress} - ${blockNumber}`, async function () {
+          idleDaoPool = await idleDao.setupEventPool(
+            tokensList[poolAddress],
+            blockNumber,
+          );
+
+          expect(idleDaoPool).not.toBeNull();
+        });
+
+        Object.entries(events).forEach(
+          ([eventName, blockNumbers]: [string, number[]]) => {
+            describe(`${eventName}`, () => {
+              blockNumbers.forEach((blockNumber: number) => {
+                it(`State after ${blockNumber}`, async function () {
+                  await testEventSubscriber(
+                    idleDaoPool!,
+                    idleDaoPool!.addressesSubscribed,
+                    (_blockNumber: number) =>
+                      fetchPoolState(
+                        idleDaoPool!,
+                        _blockNumber,
+                        poolAddress,
+                        logger,
+                      ),
+                    blockNumber,
+                    `${dexKey}_${poolAddress}`,
+                    dexHelper.provider,
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+});

package/src/dex/idle-dao/idle-dao-integration.test.ts

@@ -0,0 +1,166 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { IdleDao } from './idle-dao';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+
+async function testForIntegration(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const TokenA = Tokens[network][tokenASymbol];
+  const TokenB = Tokens[network][tokenBSymbol];
+  const tokenAAmounts = [
+    0n,
+    BigInt(tokenAAmount),
+    BigInt(tokenAAmount) * BigInt(2),
+  ];
+  const tokenBAmounts = [
+    0n,
+    BigInt(tokenBAmount),
+    BigInt(tokenBAmount) * BigInt(2),
+  ];
+
+  describe('IdleDao', function () {
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const idleDao = new IdleDao(network, dexKey, dexHelper);
+
+      await idleDao.initializePricing(blocknumber);
+
+      const pools = await idleDao.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.SELL,
+        blocknumber,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await idleDao.getPricesVolume(
+        TokenA,
+        TokenB,
+        tokenAAmounts,
+        SwapSide.SELL,
+        blocknumber,
+        pools,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, tokenAAmounts, SwapSide.SELL, dexKey);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const idleDao = new IdleDao(network, dexKey, dexHelper);
+
+      await idleDao.initializePricing(blocknumber);
+
+      const pools = await idleDao.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.BUY,
+        blocknumber,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await idleDao.getPricesVolume(
+        TokenA,
+        TokenB,
+        tokenBAmounts,
+        SwapSide.BUY,
+        blocknumber,
+        pools,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, tokenBAmounts, SwapSide.BUY, dexKey);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const idleDao = new IdleDao(network, dexKey, dexHelper);
+
+      const poolLiquidity = await idleDao.getTopPoolsForToken(
+        TokenA.address,
+        10,
+      );
+
+      checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+    });
+  });
+}
+
+describe('IdleDao E2E', () => {
+  const dexKey = 'IdleDao';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const tests = [
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'AA_wstETH',
+        tokenAAmount: '1000000000000000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDC',
+        tokenBSymbol: 'AA_idle_cpPOR-USDC',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDT',
+        tokenBSymbol: 'BB_idle_cpFAS-USDT',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'WETH',
+        tokenBSymbol: 'BB_Re7WETH',
+        tokenAAmount: '100000000000000',
+        tokenBAmount: '100000000000000',
+      },
+      {
+        tokenASymbol: 'WETH',
+        tokenBSymbol: 'AA_Re7WETH',
+        tokenAAmount: '1000000000000000',
+        tokenBAmount: '1000000000000000',
+      },
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'AA_iETHv2',
+        tokenAAmount: '1000000000000000',
+        tokenBAmount: '1000000000000000',
+      },
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'BB_iETHv2',
+        tokenAAmount: '1000000000000000',
+        tokenBAmount: '1000000000000000',
+      },
+    ];
+
+    tests.forEach(testData => {
+      testForIntegration(
+        network,
+        dexKey,
+        testData.tokenASymbol,
+        testData.tokenBSymbol,
+        testData.tokenAAmount,
+        testData.tokenBAmount,
+      );
+    });
+  });
+});

package/src/dex/idle-dao/idle-dao-pool.ts

@@ -0,0 +1,304 @@
+import { AbiItem } from 'web3-utils';
+import BigNumber from 'bignumber.js';
+import { Contract } from 'web3-eth-contract';
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import { Log, Logger } from '../../types';
+import { catchParseLogError } from '../../utils';
+import ERC20_ABI from '../../abi/erc20.json';
+import CDO_ABI from '../../abi/idle-dao/idle-cdo.json';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { PoolState, IdleToken, PoolsState } from './types';
+import { IdleDaoPollingPool } from './idle-dao-pooling-pool';
+import { getTokensByCdoAddress } from './tokens';
+import { ObjWithUpdateInfo } from '../../lib/stateful-rpc-poller/types';
+import { IdleDao } from './idle-dao';
+
+type BlocksTransfers = Record<
+  number,
+  {
+    underlyingAmount: BigNumber;
+    idleAmount: BigNumber;
+    processed: boolean;
+  }
+>;
+
+export class IdleDaoEventPool extends StatefulEventSubscriber<PoolState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<PoolState>,
+      log: Readonly<Log>,
+    ) => Promise<DeepReadonly<PoolState> | null>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  cdoContract: Contract;
+  poolInterface: Interface;
+  addressesSubscribed: string[];
+  blocksTransfers: BlocksTransfers = {};
+
+  constructor(
+    readonly parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    protected logger: Logger,
+    protected idleToken: IdleToken,
+    protected IdleDao: IdleDao,
+  ) {
+    // TODO: Add pool name
+    super(parentName, idleToken.idleSymbol, dexHelper, logger);
+
+    this.poolInterface = new Interface(ERC20_ABI);
+
+    // TODO: make logDecoder decode logs that
+    this.logDecoder = (log: Log) => this.poolInterface.parseLog(log);
+
+    this.addressesSubscribed = [idleToken.address.toLowerCase()];
+
+    const cdoTokens = getTokensByCdoAddress(this.idleToken.cdoAddress);
+    if (cdoTokens) {
+      cdoTokens.forEach((idleToken: IdleToken) => {
+        if (
+          !this.addressesSubscribed.includes(
+            idleToken.idleAddress.toLowerCase(),
+          )
+        ) {
+          this.addressesSubscribed.push(idleToken.idleAddress.toLowerCase());
+        }
+      });
+    }
+
+    // this.logger.debug('addressesSubscribed', this.idleToken.idleAddress, this.addressesSubscribed)
+
+    // Add handlers
+    this.handlers['Transfer'] = this.handleCoinTransfer.bind(this);
+
+    this.idleToken = idleToken;
+    this.cdoContract = new dexHelper.web3Provider.eth.Contract(
+      CDO_ABI as AbiItem[],
+      this.idleToken.cdoAddress,
+    );
+  }
+
+  /**
+   * 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: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        const result = await this.handlers[event.name](event, state, log);
+        return result;
+      }
+    } 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>> {
+    const tranchePrice = await this.cdoContract.methods['virtualPrice'](
+      this.idleToken.idleAddress,
+    ).call({}, blockNumber);
+    return {
+      tokenPrice: BigInt(tranchePrice),
+    };
+  }
+
+  setBlockState(blockNumber: number, state: PoolState): void {
+    this.logger.debug(
+      'setBlockState',
+      blockNumber,
+      this.idleToken.idleAddress,
+      state,
+    );
+    return this._setState(state, blockNumber);
+  }
+
+  async handleCoinTransfer(
+    event: any,
+    state: PoolState,
+    log: Log,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const idleTokens = getTokensByCdoAddress(this.idleToken.cdoAddress);
+    if (!idleTokens) return null;
+
+    const pollingPool = new IdleDaoPollingPool(
+      this.parentName,
+      this.parentName,
+      this.dexHelper,
+      idleTokens,
+      this.logger,
+    );
+
+    const blockNumber = log.blockNumber;
+    let poolsState: ObjWithUpdateInfo<PoolsState> | null = null;
+
+    if (log.address.toLowerCase() === this.idleToken.address.toLowerCase()) {
+      if (
+        event.args.dst.toLowerCase() ===
+          this.idleToken.cdoAddress.toLowerCase() ||
+        event.args.src.toLowerCase() === this.idleToken.cdoAddress.toLowerCase()
+      ) {
+        poolsState = await pollingPool.getAggregatedBlockData(blockNumber);
+      }
+    } else if (this.addressesSubscribed.includes(log.address.toLowerCase())) {
+      poolsState = await pollingPool.getAggregatedBlockData(blockNumber);
+    }
+
+    // Update pools with the new state
+    if (poolsState) {
+      Object.keys(poolsState.value as PoolsState).forEach(
+        (idleAddress: string) => {
+          const poolState = poolsState?.value?.[idleAddress];
+          if (poolState) {
+            this.IdleDao.setEventPoolStateBlock(
+              idleAddress,
+              poolsState!.blockNumber,
+              poolState,
+            );
+
+            // Overwrite state
+            if (idleAddress === this.idleToken.idleAddress) {
+              state = poolState;
+            }
+          }
+        },
+      );
+    }
+
+    return state;
+  }
+
+  processBlockTransfer(blockNumber: number, state: PoolState): PoolState {
+    if (
+      !this.blocksTransfers[blockNumber] ||
+      this.blocksTransfers[blockNumber].processed
+    )
+      return state;
+    const idleAmount = this.blocksTransfers[blockNumber].idleAmount.div(1e18);
+    const underlyingAmount = this.blocksTransfers[
+      blockNumber
+    ].underlyingAmount.div(`1e${this.idleToken.decimals}`);
+    if (idleAmount.gt(0) && underlyingAmount.gt(0)) {
+      const tokenPrice = BigInt(
+        BigNumber.maximum(idleAmount, underlyingAmount)
+          .div(BigNumber.minimum(idleAmount, underlyingAmount))
+          .times(`1e${this.idleToken.decimals}`)
+          .toFixed(0),
+      );
+      this.logger.debug(
+        'tokenPrice',
+        blockNumber,
+        this.idleToken.idleSymbol,
+        this.idleToken.decimals,
+        idleAmount.toString(),
+        underlyingAmount.toString(),
+        tokenPrice.toString(),
+      );
+      this.blocksTransfers[blockNumber].processed = true;
+      return {
+        tokenPrice,
+      };
+    }
+    return state;
+  }
+
+  async handleCoinTransfer_old(
+    event: any,
+    state: PoolState,
+    log: Log,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    // Handle underlying token transfer
+    if (log.address.toLowerCase() === this.idleToken.address.toLowerCase()) {
+      if (
+        event.args.dst.toLowerCase() ===
+          this.idleToken.cdoAddress.toLowerCase() ||
+        event.args.src.toLowerCase() === this.idleToken.cdoAddress.toLowerCase()
+      ) {
+        if (!this.blocksTransfers[log.blockNumber]) {
+          this.blocksTransfers[log.blockNumber] = {
+            processed: false,
+            idleAmount: BigNumber(0),
+            underlyingAmount: BigNumber(0),
+          };
+        }
+        this.logger.debug(
+          'UnderlyingAmount',
+          log.blockNumber,
+          'event',
+          event,
+          'log',
+          log,
+          BigNumber(BigInt(event.args.wad).toString()).toFixed(),
+        );
+        this.blocksTransfers[log.blockNumber].underlyingAmount = BigNumber(
+          BigInt(event.args.wad).toString(),
+        );
+      }
+    }
+    // Handle idle token transfer
+    else if (
+      log.address.toLowerCase() === this.idleToken.idleAddress.toLowerCase()
+    ) {
+      this.logger.debug(
+        'IdleToken Transfer',
+        log.blockNumber,
+        'event',
+        event,
+        'log',
+        log,
+      );
+      if (
+        event.args.src.toLowerCase() ===
+          '0x0000000000000000000000000000000000000000' ||
+        event.args.dst.toLowerCase() ===
+          '0x0000000000000000000000000000000000000000'
+      ) {
+        if (!this.blocksTransfers[log.blockNumber]) {
+          this.blocksTransfers[log.blockNumber] = {
+            processed: false,
+            idleAmount: BigNumber(0),
+            underlyingAmount: BigNumber(0),
+          };
+        }
+        this.logger.debug(
+          'IdleAmount',
+          log.blockNumber,
+          'event',
+          event,
+          'log',
+          log,
+          BigNumber(BigInt(event.args.wad).toString()).toFixed(),
+        );
+        this.blocksTransfers[log.blockNumber].idleAmount = BigNumber(
+          BigInt(event.args.wad).toString(),
+        );
+      }
+    }
+
+    return this.processBlockTransfer(log.blockNumber, state);
+  }
+}