@paraswap/dex-lib 3.9.6 → 3.9.7-fluid-dex.1

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

@@ -0,0 +1,225 @@
+/* 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 { FluidDex } from './fluid-dex';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import ResolverABI from '../../abi/fluid-dex/resolver.abi.json';
+
+/*
+  README
+  ======
+
+  This test script adds tests for FluidDex general integration
+  with the DEX interface. The test cases below are example tests.
+  It is recommended to add tests which cover FluidDex 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)
+*/
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  amounts: bigint[],
+  funcName: string,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(funcName, [
+      '0x0b1a513ee24972daef112bc777a5610d4325c9e7',
+      funcName == 'estimateSwapIn' ? true : false,
+      amount,
+      funcName == 'estimateSwapIn' ? 0 : 2n * amount,
+    ]),
+  }));
+}
+
+function decodeReaderResult(
+  results: Result,
+  readerIface: Interface,
+  funcName: string,
+) {
+  return results.map(result => {
+    return BigInt(result);
+  });
+}
+
+async function checkOnChainPricing(
+  fluidDex: FluidDex,
+  funcName: string,
+  blockNumber: number,
+  prices: bigint[],
+  amounts: bigint[],
+) {
+  const resolverAddress = '0xE8a07a32489BD9d5a00f01A55749Cf5cB854Fd13';
+
+  const readerIface = new Interface(ResolverABI);
+
+  const readerCallData = getReaderCalldata(
+    resolverAddress,
+    readerIface,
+    amounts.slice(1),
+    funcName,
+  );
+  const readerResult = (
+    await fluidDex.dexHelper.multiContract.methods
+      .aggregate(readerCallData)
+      .call({}, blockNumber)
+  ).returnData;
+
+  const expectedPrices = [0n].concat(
+    decodeReaderResult(readerResult, readerIface, funcName),
+  );
+}
+
+async function testPricingOnNetwork(
+  fluidDex: FluidDex,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await fluidDex.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await fluidDex.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+  console.log(
+    'logged params : ',
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  expect(poolPrices).not.toBeNull();
+  if (fluidDex.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check if onchain pricing equals to calculated ones
+  await checkOnChainPricing(
+    fluidDex,
+    funcNameToCheck,
+    blockNumber,
+    poolPrices![0].prices,
+    amounts,
+  );
+}
+
+describe('FluidDex', function () {
+  const dexKey = 'FluidDex';
+  let blockNumber: number;
+  let fluidDex: FluidDex;
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    // Don't forget to update relevant tokens in constant-e2e.ts
+    const srcTokenSymbol = 'wstETH';
+    const destTokenSymbol = 'ETH';
+
+    const amountsForSell = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals - 10],
+    ];
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.provider.getBlockNumber();
+      fluidDex = new FluidDex(network, dexKey, dexHelper);
+      if (fluidDex.initializePricing) {
+        await fluidDex.initializePricing(blockNumber);
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      await testPricingOnNetwork(
+        fluidDex,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.SELL,
+        amountsForSell,
+        'estimateSwapIn',
+      );
+    });
+
+    it('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const newFluidDex = new FluidDex(network, dexKey, dexHelper);
+      await newFluidDex.initializePricing(blockNumber);
+      if (newFluidDex.updatePoolState) {
+        await newFluidDex.updatePoolState();
+      }
+      const poolLiquidity = await newFluidDex.getTopPoolsForToken(
+        tokens[srcTokenSymbol].address,
+        1,
+      );
+
+      if (!newFluidDex.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][srcTokenSymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
+});

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

@@ -0,0 +1,178 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import { Log, Logger } from '../../types';
+import { catchParseLogError } from '../../utils';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import ResolverABI from '../../abi/fluid-dex/resolver.abi.json';
+import LiquidityABI from '../../abi/fluid-dex/liquidityUserModule.abi.json';
+import {
+  CommonAddresses,
+  FluidDexPoolState,
+  CollateralReserves,
+  DebtReserves,
+} from './types';
+import { Address } from '../../types';
+import { Contract } from 'ethers';
+
+export class FluidDexEventPool extends StatefulEventSubscriber<FluidDexPoolState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<FluidDexPoolState>,
+      log: Readonly<Log>,
+    ) => Promise<DeepReadonly<FluidDexPoolState> | null>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  addressesSubscribed: Address[];
+  protected liquidityIface = new Interface(LiquidityABI);
+
+  constructor(
+    readonly parentName: string,
+    readonly pool: Address,
+    readonly commonAddresses: CommonAddresses,
+    protected network: number,
+    readonly dexHelper: IDexHelper,
+    logger: Logger,
+  ) {
+    super(parentName, 'FluidDex_' + pool, dexHelper, logger);
+
+    this.logDecoder = (log: Log) => this.liquidityIface.parseLog(log);
+    this.addressesSubscribed = [commonAddresses.liquidityProxy];
+
+    // Add handlers
+    this.handlers['LogOperate'] = this.handleOperate.bind(this);
+  }
+
+  /**
+   * Handle a trade rate change on the pool.
+   */
+  async handleOperate(
+    event: any,
+    state: DeepReadonly<FluidDexPoolState>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<FluidDexPoolState> | null> {
+    if (!(event.args.user in [this.pool])) {
+      return null;
+    }
+    const resolverContract = new Contract(
+      this.commonAddresses.resolver,
+      ResolverABI,
+      this.dexHelper.provider,
+    );
+    const rawResult = await resolverContract.callStatic.getPoolReservesAdjusted(
+      this.pool,
+      {
+        blockTag: this.dexHelper.provider,
+      },
+    );
+
+    const generatedState = this.convertToFluidDexPoolState(rawResult);
+
+    this.setState(
+      generatedState,
+      await this.dexHelper.provider.getBlockNumber(),
+    );
+
+    return generatedState;
+  }
+
+  /**
+   * 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
+   */
+  async processLog(
+    state: DeepReadonly<FluidDexPoolState>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<FluidDexPoolState> | null> {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return await this.handlers[event.name](event, state, log);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
+
+    return null;
+  }
+
+  async getStateOrGenerate(
+    blockNumber: number,
+    readonly: boolean = false,
+  ): Promise<FluidDexPoolState> {
+    let state = this.getState(blockNumber);
+    if (!state) {
+      state = await this.generateState(blockNumber);
+      if (!readonly) this.setState(state, blockNumber);
+    }
+    return state;
+  }
+
+  /**
+   * 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<FluidDexPoolState>> {
+    const resolverContract = new Contract(
+      this.commonAddresses.resolver,
+      ResolverABI,
+      this.dexHelper.provider,
+    );
+    const rawResult = await resolverContract.callStatic.getPoolReservesAdjusted(
+      this.pool,
+      {
+        blockTag: blockNumber,
+      },
+    );
+
+    const convertedResult = this.convertToFluidDexPoolState(rawResult);
+
+    return convertedResult;
+  }
+
+  private convertToFluidDexPoolState(input: any[]): FluidDexPoolState {
+    // Ignore the first three addresses
+    const [, , , feeHex, collateralReservesHex, debtReservesHex] = input;
+    // Convert fee from hex to number
+    const fee = Number(feeHex.toString());
+
+    // Convert collateral reserves
+    const collateralReserves: CollateralReserves = {
+      token0RealReserves: BigInt(collateralReservesHex[0].toString()),
+      token1RealReserves: BigInt(collateralReservesHex[1].toString()),
+      token0ImaginaryReserves: BigInt(collateralReservesHex[2].toString()),
+      token1ImaginaryReserves: BigInt(collateralReservesHex[3].toString()),
+    };
+
+    // Convert debt reserves
+    const debtReserves: DebtReserves = {
+      token0Debt: BigInt(debtReservesHex[0].toString()),
+      token1Debt: BigInt(debtReservesHex[1].toString()),
+      token0RealReserves: BigInt(debtReservesHex[2].toString()),
+      token1RealReserves: BigInt(debtReservesHex[3].toString()),
+      token0ImaginaryReserves: BigInt(debtReservesHex[4].toString()),
+      token1ImaginaryReserves: BigInt(debtReservesHex[5].toString()),
+    };
+
+    return {
+      collateralReserves,
+      debtReserves,
+      fee,
+    };
+  }
+}